fix json formate from main.py index new new new thing new

main.py

@@ -128,26 +128,54 @@ from similarity_check.llm_based_scoring.llm import llm_score
 app = Flask(__name__)
 app.config['JSON_SORT_KEYS'] = False
 app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
 
 # Create a temporary directory for file uploads
 UPLOAD_FOLDER = tempfile.mkdtemp()
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 logger.info(f"Using temporary upload folder: {UPLOAD_FOLDER}")
 
-# Configure CORS for Hugging Face
+# Configure CORS for all origins
 CORS(app, resources={
     r"/*": {
-        "origins": ["*"],
+        "origins": "*",
         "methods": ["GET", "POST", "OPTIONS"],
-        "allow_headers": ["Content-Type", "Authorization", "Accept"]
+        "allow_headers": ["Content-Type", "Authorization", "Accept"],
+        "expose_headers": ["Content-Type"]
     }
 })
 
+# Global error handler for all exceptions
+@app.errorhandler(Exception)
+def handle_exception(e):
+    # Log the error for debugging
+    app.logger.error(f"Unhandled exception: {str(e)}")
+    return jsonify({
+        "error": "Internal server error",
+        "message": str(e)
+    }), 500
+
+# Handle 404 errors
+@app.errorhandler(404)
+def not_found_error(error):
+    return jsonify({
+        "error": "Not found",
+        "message": "The requested resource was not found"
+    }), 404
+
+# Handle 400 Bad Request
+@app.errorhandler(400)
+def bad_request_error(error):
+    return jsonify({
+        "error": "Bad request",
+        "message": str(error)
+    }), 400
+
 @app.route('/')
 def index():
     try:
         response = make_response(render_template('index.html'))
-        response.headers['Content-Type'] = 'text/html'
+        response.headers['Content-Type'] = 'text/html; charset=utf-8'
         return response
     except Exception as e:
         return jsonify({"error": str(e)}), 500
@@ -258,7 +286,8 @@ def compute_marks():
         correct_answers = request.form.getlist('correct_answers[]')
         if not correct_answers:
             return jsonify({
-                "error": "No correct answers provided"
+                "error": "Missing data",
+                "message": "No correct answers provided"
             }), 400
             
         # Create TFIDF values for correct answers
@@ -266,14 +295,16 @@ def compute_marks():
             max_tfidf = create_tfidf_values(correct_answers)
         except Exception as e:
             return jsonify({
-                "error": f"Error creating TFIDF values: {str(e)}"
+                "error": "TFIDF error",
+                "message": f"Error creating TFIDF values: {str(e)}"
             }), 400
         
         # Get all uploaded files
         files = request.files.getlist('file')
         if not files:
             return jsonify({
-                "error": "No files uploaded"
+                "error": "Missing data",
+                "message": "No files uploaded"
             }), 400
 
         # Create a temporary directory for processing
@@ -287,6 +318,10 @@ def compute_marks():
             # Process each file
             for file in files:
                 try:
+                    # Validate file
+                    if not file or not file.filename:
+                        continue
+
                     # Get folder structure from file path
                     path_parts = file.filename.split('/')
                     if len(path_parts) < 2:
@@ -372,7 +407,8 @@ def compute_marks():
                 
         if not results:
             return jsonify({
-                "error": "No results computed"
+                "error": "Processing error",
+                "message": "No results computed"
             }), 400
             
         # Clean the results for JSON response
@@ -381,29 +417,23 @@ def compute_marks():
             clean_student = student.encode('ascii', 'ignore').decode('ascii')
             clean_results[clean_student] = scores
             
-        return jsonify({
+        response = jsonify({
             "results": clean_results,
             "failed_files": [{
                 "file": f["file"].encode('ascii', 'ignore').decode('ascii'),
                 "error": f["error"].encode('ascii', 'ignore').decode('ascii')
             } for f in failed_files]
         })
+        response.headers['Content-Type'] = 'application/json'
+        return response
         
     except Exception as e:
         error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
         return jsonify({
-            "error": f"Error computing marks: {error_msg}"
+            "error": "Server error",
+            "message": f"Error computing marks: {error_msg}"
         }), 500
 
-# Add error handlers for common HTTP errors
-@app.errorhandler(404)
-def not_found_error(error):
-    return jsonify({"error": "Resource not found"}), 404
-
-@app.errorhandler(500)
-def internal_error(error):
-    return jsonify({"error": "Internal server error"}), 500
-
 @app.route('/check_logs')
 def check_logs():
     try:

templates/index.html

@@ -987,6 +987,7 @@
                     throw new Error("No valid image files found in the uploaded folder");
                 }
 
+                console.log('Sending request to compute marks...');
                 const response = await fetch('/compute_marks', {
                     method: 'POST',
                     headers: {
@@ -995,20 +996,25 @@
                     body: formData
                 });
 
-                let result;
+                console.log('Response status:', response.status);
+                console.log('Response headers:', Object.fromEntries(response.headers.entries()));
+
+                // Check if the response is JSON
                 const contentType = response.headers.get('content-type');
-                if (contentType && contentType.includes('application/json')) {
-                    result = await response.json();
-                } else {
+                if (!contentType || !contentType.includes('application/json')) {
+                    console.error('Non-JSON response:', await response.text());
                     throw new Error('Server did not return JSON');
                 }
 
+                const result = await response.json();
+                console.log('Parsed response:', result);
+
                 if (!response.ok) {
-                    throw new Error(result.error || `Server returned error ${response.status}`);
+                    throw new Error(result.message || result.error || `Server returned error ${response.status}`);
                 }
 
                 if (result.error) {
-                    throw new Error(result.error);
+                    throw new Error(result.message || result.error);
                 }
 
                 if (!result.results) {
@@ -1026,7 +1032,7 @@
                 }
 
             } catch (error) {
-                console.error('Error:', error);
+                console.error('Error details:', error);
                 alert('Error computing marks: ' + error.message);
             } finally {
                 hideLoading();