0x5t4l1n/OpenLearnX
1
0
Fork 0
mirror of https://github.com/th30d4y/OpenLearnX.git synced 2026-05-26 11:25:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

update error

Browse Source
This commit is contained in:
5t4l1n
2025-07-28 00:51:24 +05:30
parent efd6708e5a
commit 7f6531b097
3 changed files with 400 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/main.py
+120 -98
View File
@@ -152,7 +152,7 @@ def get_db():
return client.openlearnx
# ===================================================================
# ✅ ENHANCED DYNAMIC SCORING SYSTEM
# ✅ ENHANCED DYNAMIC SCORING SYSTEM - CORRECTED VERSION
# ===================================================================
def calculate_dynamic_score(code, language, problem):
@@ -161,119 +161,116 @@ def calculate_dynamic_score(code, language, problem):
from contextlib import redirect_stdout, redirect_stderr
import time
# Handle both old and new problem formats
test_cases = problem.get('test_cases', [])
total_points = problem.get('total_points', 100)
# ✅ FIXED: Handle empty test cases properly
if not test_cases:
# Create a basic test case for simple execution
test_cases = [{
"input": "",
"expected_output": "",
"description": "Basic execution test",
"points": total_points
}]
start_time = time.time()
passed_tests = 0
total_tests = len(test_cases) if test_cases else 1
total_tests = len(test_cases)
test_results = []
points_earned = 0
print(f"🧮 Enhanced Dynamic scoring - {total_tests} test cases, {total_points} total points")
try:
if test_cases:
for i, test_case in enumerate(test_cases):
test_input = test_case.get('input', '')
expected_output = test_case.get('expected_output', '').strip()
test_points = test_case.get('points', total_points // total_tests)
for i, test_case in enumerate(test_cases):
test_input = test_case.get('input', '')
expected_output = test_case.get('expected_output', '').strip()
test_points = test_case.get('points', total_points // total_tests)
print(f"📋 Test {i+1}: Input='{test_input}', Expected='{expected_output}', Points={test_points}")
try:
stdout_buffer = io.StringIO()
stderr_buffer = io.StringIO()
print(f"📋 Test {i+1}: Input='{test_input}', Expected='{expected_output}', Points={test_points}")
# ✅ ENHANCED: Better execution environment
exec_globals = {
"__builtins__": __builtins__,
"__name__": "__main__"
}
try:
stdout_buffer = io.StringIO()
stderr_buffer = io.StringIO()
exec_globals = {"__builtins__": __builtins__}
if test_input:
# Handle multiple input lines
input_lines = test_input.split('\n') if '\n' in test_input else [test_input]
input_iter = iter(input_lines)
exec_globals['input'] = lambda prompt='': next(input_iter, '')
with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
exec(code, exec_globals)
actual_output = stdout_buffer.getvalue().strip()
stderr_content = stderr_buffer.getvalue().strip()
print(f"🔍 Test {i+1} - Actual: '{actual_output}', Expected: '{expected_output}'")
# Enhanced comparison with tolerance for whitespace
if actual_output == expected_output or actual_output.replace(' ', '') == expected_output.replace(' ', ''):
passed_tests += 1
points_earned += test_points
test_results.append({
"test_number": i + 1,
"passed": True,
"input": test_input,
"expected_output": expected_output,
"actual_output": actual_output,
"points_earned": test_points,
"description": test_case.get('description', f'Test case {i+1}'),
"execution_time": time.time() - start_time
})
print(f"✅ Test {i+1} PASSED - {test_points} points earned")
else:
test_results.append({
"test_number": i + 1,
"passed": False,
"input": test_input,
"expected_output": expected_output,
"actual_output": actual_output,
"points_earned": 0,
"error": f"Output mismatch. Got '{actual_output}', expected '{expected_output}'",
"description": test_case.get('description', f'Test case {i+1}'),
"stderr": stderr_content if stderr_content else None
})
print(f"❌ Test {i+1} FAILED - Expected '{expected_output}', got '{actual_output}'")
# Handle input simulation
if test_input:
input_lines = test_input.split('\n') if '\n' in test_input else [test_input]
input_iter = iter(input_lines)
exec_globals['input'] = lambda prompt='': next(input_iter, '')
else:
exec_globals['input'] = lambda prompt='': ''
except Exception as e:
print(f"❌ Test {i+1} EXCEPTION - {str(e)}")
with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
exec(code, exec_globals)
actual_output = stdout_buffer.getvalue().strip()
stderr_content = stderr_buffer.getvalue().strip()
print(f"🔍 Test {i+1} - Actual: '{actual_output}', Expected: '{expected_output}'")
# ✅ ENHANCED: Better output comparison
is_correct = False
if expected_output == "":
# For basic execution tests, just check if code runs without error
is_correct = stderr_content == ""
else:
# Compare outputs with tolerance for whitespace
is_correct = (
actual_output == expected_output or
actual_output.replace(' ', '') == expected_output.replace(' ', '') or
actual_output.lower().strip() == expected_output.lower().strip()
)
if is_correct:
passed_tests += 1
points_earned += test_points
test_results.append({
"test_number": i + 1,
"passed": True,
"input": test_input,
"expected_output": expected_output,
"actual_output": actual_output,
"points_earned": test_points,
"description": test_case.get('description', f'Test case {i+1}'),
"execution_time": round(time.time() - start_time, 3)
})
print(f"✅ Test {i+1} PASSED - {test_points} points earned")
else:
test_results.append({
"test_number": i + 1,
"passed": False,
"input": test_input,
"expected_output": expected_output,
"actual_output": f"Error: {str(e)}",
"actual_output": actual_output,
"points_earned": 0,
"error": str(e),
"error": f"Output mismatch. Got '{actual_output}', expected '{expected_output}'",
"description": test_case.get('description', f'Test case {i+1}'),
"error_type": type(e).__name__
"stderr": stderr_content if stderr_content else None
})
else:
# Fallback: Basic execution test
try:
stdout_buffer = io.StringIO()
stderr_buffer = io.StringIO()
with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
exec(code, {"__builtins__": __builtins__})
passed_tests = 1
points_earned = total_points
test_results = [{
"test_number": 1,
"passed": True,
"input": "",
"expected_output": "Code should execute without errors",
"actual_output": stdout_buffer.getvalue().strip(),
"points_earned": total_points,
"description": "Basic execution test"
}]
print(f"❌ Test {i+1} FAILED - Expected '{expected_output}', got '{actual_output}'")
except Exception as e:
test_results = [{
"test_number": 1,
print(f"❌ Test {i+1} EXCEPTION - {str(e)}")
test_results.append({
"test_number": i + 1,
"passed": False,
"input": "",
"expected_output": "Code should execute without errors",
"actual_output": f"Error: {str(e)}",
"input": test_input,
"expected_output": expected_output,
"actual_output": f"Runtime Error: {str(e)}",
"points_earned": 0,
"error": str(e),
"description": "Basic execution test",
"description": test_case.get('description', f'Test case {i+1}'),
"error_type": type(e).__name__
}]
})
except Exception as e:
print(f"❌ Scoring system error: {str(e)}")
@@ -288,6 +285,7 @@ def calculate_dynamic_score(code, language, problem):
"description": "Scoring system error",
"error_type": type(e).__name__
}]
total_tests = 1
execution_time = time.time() - start_time
final_score = int((points_earned / total_points) * 100) if total_points > 0 else 0
@@ -303,7 +301,7 @@ def calculate_dynamic_score(code, language, problem):
'details': {
'points_earned': points_earned,
'total_points': total_points,
'scoring_method': 'test_cases',
'scoring_method': 'enhanced_dynamic',
'language': language
}
}
@@ -374,7 +372,7 @@ def generate_ai_quiz_direct():
def health_root():
return jsonify({
"status": "OpenLearnX API running",
"version": "2.5.0 - ENHANCED ULTIMATE EDITION",
"version": "2.6.0 - CORRECTED ULTIMATE EDITION",
"timestamp": datetime.now().isoformat(),
"features": {
"mongodb": MONGO_SERVICE_AVAILABLE,
@@ -384,13 +382,15 @@ def health_root():
"ai_quiz_service": AI_QUIZ_SERVICE_AVAILABLE,
"docker": check_docker_availability(),
"dynamic_scoring": True,
"ultimate_leaderboard_fix": True,
"enhanced_scoring": True,
"exam_submission": True,
"adaptive_quiz": True,
"enhanced_security": True,
"ai_integration": AI_QUIZ_SERVICE_AVAILABLE
},
"endpoints": {
"exam": "/api/exam/*",
"exam_submit": "/api/exam/submit-solution",
"quizzes": "/api/quizzes/*",
"compiler": "/api/compiler/*",
"ai_quiz": "/api/quizzes/generate-ai" if AI_QUIZ_SERVICE_AVAILABLE else "unavailable",
@@ -410,9 +410,10 @@ def api_health():
"compiler": COMPILER_SERVICE_AVAILABLE,
"ai_quiz_service": AI_QUIZ_SERVICE_AVAILABLE,
"docker": check_docker_availability(),
"ultimate_leaderboard_fix": True,
"enhanced_scoring": True,
"exam_submission_fixed": True,
"adaptive_quiz": True,
"enhanced_version": "2.5.0"
"enhanced_version": "2.6.0"
}
# Enhanced MongoDB connection test
@@ -436,7 +437,6 @@ def api_health():
# AI service health check
if AI_QUIZ_SERVICE_AVAILABLE:
try:
# Quick test of AI service
services["ai_models_loaded"] = hasattr(ai_service, 'model_available') and ai_service.model_available
except Exception as e:
services["ai_service_error"] = str(e)
@@ -446,7 +446,7 @@ def api_health():
"services": services,
"blueprints_registered": blueprints_registered,
"blueprints_failed": blueprints_failed,
"version": "2.5.0-enhanced"
"version": "2.6.0-corrected"
}), 200 if status == "healthy" else 503
# ===================================================================
@@ -479,7 +479,14 @@ def not_found(e):
return jsonify({
"error": "Not Found",
"path": request.path,
"method": request.method
"method": request.method,
"available_endpoints": [
"/api/exam/submit-solution",
"/api/exam/create-exam",
"/api/exam/join-exam",
"/api/quizzes/*",
"/api/health"
]
}), 404
@app.errorhandler(500)
@@ -487,7 +494,8 @@ def internal_error(e):
logger.error(f"500 Error: {e}")
return jsonify({
"error": "Internal Server Error",
"timestamp": datetime.now().isoformat()
"timestamp": datetime.now().isoformat(),
"suggestion": "Check server logs for detailed error information"
}), 500
# ===================================================================
@@ -495,11 +503,23 @@ def internal_error(e):
# ===================================================================
if __name__ == "__main__":
print("🚀 Starting OpenLearnX Backend v2.5.0 - ENHANCED ULTIMATE EDITION")
print("📚 Features: Enhanced Dynamic Scoring, AI Quiz Integration, Better Security")
print("🚀 Starting OpenLearnX Backend v2.6.0 - CORRECTED ULTIMATE EDITION")
print("📚 Features: Enhanced Dynamic Scoring, AI Quiz Integration, Fixed Exam Submission")
print(f"🤖 AI Quiz Service: {'✅ Available' if AI_QUIZ_SERVICE_AVAILABLE else '❌ Unavailable'}")
print(f"📊 MongoDB: {'✅ Available' if MONGO_SERVICE_AVAILABLE else '❌ Unavailable'}")
print(f"🔧 Enhanced Scoring: ✅ Available")
print("🌐 Server starting on http://0.0.0.0:5000")
# ✅ STARTUP VALIDATION
print("\n📋 Startup Validation:")
print(f" - Blueprints registered: {len(blueprints_registered)}")
if blueprints_failed:
print(f" - Blueprint failures: {len(blueprints_failed)}")
for prefix, error in blueprints_failed:
print(f" ❌ {prefix}: {error}")
print(f" - Database: {'✅ Connected' if MONGO_SERVICE_AVAILABLE else '❌ Disconnected'}")
print(f" - AI Service: {'✅ Ready' if AI_QUIZ_SERVICE_AVAILABLE else '❌ Not Available'}")
try:
app.run(
host="0.0.0.0",
@@ -511,3 +531,5 @@ if __name__ == "__main__":
print("\n👋 Server stopped by user")
except Exception as e:
print(f"❌ Server startup failed: {e}")
import traceback
traceback.print_exc()
backend/routes/exam.py
+104 -16
View File
@@ -326,10 +326,10 @@ def start_exam():
print(f"❌ Error starting exam: {str(e)}")
return jsonify({"error": str(e)}), 500
# ✅ MISSING ROUTE - This was causing the 404 error!
# ✅ CRITICAL: The submit-solution route with enhanced debugging
@bp.route('/submit-solution', methods=['POST', 'OPTIONS'])
def submit_solution():
"""Submit coding solution for evaluation"""
"""Submit coding solution for evaluation - WITH DEBUG LOGGING"""
if request.method == "OPTIONS":
response = jsonify({'status': 'ok'})
response.headers.add("Access-Control-Allow-Origin", "*")
@@ -338,17 +338,80 @@ def submit_solution():
return response
try:
data = request.get_json()
# ✅ ENHANCED DEBUG LOGGING
print(f"🔍 ===== SUBMIT SOLUTION DEBUG =====")
print(f"🔍 Raw request data: {request.data}")
print(f"🔍 Content-Type: {request.headers.get('Content-Type')}")
print(f"🔍 Request form: {dict(request.form) if request.form else 'None'}")
print(f"🔍 Request args: {dict(request.args) if request.args else 'None'}")
print(f"🔍 Request method: {request.method}")
# Try to get JSON data
try:
data = request.get_json()
print(f"🔍 Parsed JSON data: {data}")
except Exception as json_error:
print(f"🔍 JSON parsing error: {json_error}")
data = None
# Check what we actually received
if not data:
print("❌ No JSON data received")
# Try alternative data sources
if request.form:
print("🔍 Trying to use form data instead...")
data = {
'exam_code': request.form.get('exam_code'),
'username': request.form.get('username'),
'code': request.form.get('code'),
'language': request.form.get('language', 'python'),
'problem_id': request.form.get('problem_id', 'problem_1')
}
print(f"🔍 Form data converted: {data}")
else:
return jsonify({
"success": False,
"error": "No JSON data received",
"debug_info": {
"content_type": request.headers.get('Content-Type'),
"raw_data": request.data.decode() if request.data else None,
"form_data": dict(request.form) if request.form else None,
"suggestion": "Make sure Content-Type is 'application/json' and data is valid JSON"
}
}), 400
# Extract fields with detailed logging
exam_code = data.get('exam_code')
username = data.get('username')
problem_id = data.get('problem_id', 'problem_1')
code = data.get('code')
language = data.get('language', 'python')
if not all([exam_code, username, code]):
print(f"🔍 Extracted fields:")
print(f" - exam_code: '{exam_code}' (type: {type(exam_code)})")
print(f" - username: '{username}' (type: {type(username)})")
print(f" - problem_id: '{problem_id}' (type: {type(problem_id)})")
print(f" - code: '{code[:50] if code else None}...' (length: {len(code) if code else 0})")
print(f" - language: '{language}' (type: {type(language)})")
# Enhanced validation with specific field checking
missing_fields = []
if not exam_code or str(exam_code).strip() == '':
missing_fields.append('exam_code')
if not username or str(username).strip() == '':
missing_fields.append('username')
if not code or str(code).strip() == '':
missing_fields.append('code')
if missing_fields:
print(f"❌ Missing fields: {missing_fields}")
return jsonify({
"success": False,
"error": "Missing required fields: exam_code, username, code"
"error": f"Missing required fields: {', '.join(missing_fields)}",
"received_data": data,
"missing_fields": missing_fields,
"debug_info": "Check that your frontend is sending all required fields with non-empty values"
}), 400
print(f"📝 Solution submission: {username} -> {exam_code} (Problem: {problem_id})")
@@ -356,8 +419,11 @@ def submit_solution():
# Find the exam
exam = db.exams.find_one({"exam_code": exam_code.upper()})
if not exam:
print(f"❌ Exam not found: {exam_code}")
return jsonify({"success": False, "error": "Exam not found"}), 404
print(f"✅ Found exam: {exam['title']}")
# Find the specific problem (support both old and new format)
problem = None
if exam.get('problems'):
@@ -367,22 +433,29 @@ def submit_solution():
problem['id'] = 'problem_1'
if not problem:
print(f"❌ Problem not found: {problem_id}")
return jsonify({"success": False, "error": "Problem not found"}), 404
print(f"✅ Found problem: {problem.get('title', 'Untitled')}")
# Use the enhanced dynamic scoring system from main.py
try:
from main import calculate_dynamic_score
print(f"🧮 Running dynamic scoring system...")
result = calculate_dynamic_score(code, language, problem)
except ImportError:
print(f"🏆 Scoring result: {result['score']}% ({result['passed_tests']}/{result['total_tests']} tests)")
except ImportError as e:
print(f"⚠️ Could not import scoring system from main.py: {e}")
# Fallback basic scoring if main function not available
result = {
'score': 50, # Default score
'score': 75, # Default score
'passed_tests': 1,
'total_tests': 1,
'test_results': [{'passed': True, 'description': 'Basic test'}],
'test_results': [{'passed': True, 'description': 'Basic execution test', 'points_earned': 75}],
'execution_time': 0.1,
'details': {'points_earned': 50, 'total_points': 100}
'details': {'points_earned': 75, 'total_points': 100}
}
print(f"🔄 Using fallback scoring: {result['score']}%")
# Create submission record
submission = {
@@ -404,22 +477,31 @@ def submit_solution():
# Save submission to submissions collection
db.submissions.insert_one(submission)
print(f"💾 Submission saved to database")
# Update participant in exam
participant_update = {
"name": username,
"score": result['score'],
"completed": True,
"submission_time": datetime.now(),
"language": language,
"submission": code,
"test_results": result['test_results']
"test_results": result['test_results'],
"joined_at": datetime.now(),
"session_id": str(uuid.uuid4())
}
exam_update_result = db.exams.update_one(
{"exam_code": exam_code.upper(), "participants.name": username},
{"$set": {f"participants.$": {**participant_update, "name": username, "joined_at": datetime.now(), "session_id": str(uuid.uuid4())}}}
{"$set": {f"participants.$": participant_update}}
)
if exam_update_result.modified_count > 0:
print(f"✅ Updated participant {username} in exam")
else:
print(f"⚠️ Could not update participant {username} in exam - may not exist")
# Update participant leaderboard in separate collection
participant_filter = {"exam_code": exam_code.upper(), "username": username}
participant = db.participants.find_one(participant_filter)
@@ -449,6 +531,7 @@ def submit_solution():
}
}
)
print(f"✅ Updated existing participant record")
else:
# Create new participant
new_participant = {
@@ -466,8 +549,9 @@ def submit_solution():
}]
}
db.participants.insert_one(new_participant)
print(f"✅ Created new participant record")
print(f"✅ Solution submitted: {result['score']}% ({result['passed_tests']}/{result['total_tests']} tests)")
print(f"✅ Solution submitted successfully: {result['score']}% ({result['passed_tests']}/{result['total_tests']} tests)")
return jsonify({
"success": True,
@@ -479,7 +563,9 @@ def submit_solution():
"test_results": result['test_results'],
"execution_time": result['execution_time'],
"points_earned": result['details']['points_earned'],
"total_points": result['details']['total_points']
"total_points": result['details']['total_points'],
"language": language,
"problem_id": problem_id
}
})
@@ -487,7 +573,11 @@ def submit_solution():
print(f"❌ Submission error: {str(e)}")
import traceback
traceback.print_exc()
return jsonify({"success": False, "error": str(e)}), 500
return jsonify({
"success": False,
"error": f"Server error: {str(e)}",
"error_type": type(e).__name__
}), 500
@bp.route("/leaderboard/<exam_code>", methods=["GET", "OPTIONS"])
def get_leaderboard(exam_code):
@@ -654,7 +744,6 @@ def get_host_dashboard(exam_code):
except Exception as e:
return jsonify({"error": str(e)}), 500
# ✅ FIXED: Remove duplicate definition
@bp.route('/info/<exam_code>', methods=['GET', 'OPTIONS'])
def get_exam_info(exam_code):
"""Get detailed information about an exam for the host panel"""
@@ -805,7 +894,6 @@ def stop_exam():
print(f"❌ Error stopping exam: {str(e)}")
return jsonify({"success": False, "error": str(e)}), 500
# ✅ FIXED: Remove duplicate definition
@bp.route('/upload-question', methods=['POST', 'OPTIONS'])
def upload_question():
"""Host uploads a custom question to their exam"""