fix main file handiling

main.py

@@ -10,6 +10,7 @@ from flask import Flask, request, jsonify, render_template, make_response
 from werkzeug.utils import secure_filename
 from dotenv import load_dotenv
 import json
+import shutil
 
 # Load environment variables
 load_dotenv()
@@ -20,12 +21,39 @@ log_dir = os.path.join(BASE_DIR, 'app_logs')
 cache_dir = os.path.join(BASE_DIR, 'app_cache')
 
 def ensure_directory(path):
-    """Create directory and ensure full permissions"""
+    """Create directory and ensure full permissions with better error handling"""
     try:
+        # First try to create the directory with full permissions
         os.makedirs(path, mode=0o777, exist_ok=True)
-        os.chmod(path, 0o777)  # Full permissions
+        
+        # Double-check the permissions and try to set them again if needed
+        current_mode = os.stat(path).st_mode & 0o777
+        if current_mode != 0o777:
+            os.chmod(path, 0o777)
+            
+        # Verify the directory is writable
+        test_file = os.path.join(path, '.test_write')
+        try:
+            with open(test_file, 'w') as f:
+                f.write('test')
+            os.remove(test_file)
+        except Exception as e:
+            raise Exception(f"Directory {path} is not writable: {str(e)}")
+            
     except Exception as e:
-        print(f"Warning: Could not set permissions for {path}: {e}")
+        # If we can't set full permissions, try with more restrictive ones
+        try:
+            os.makedirs(path, mode=0o755, exist_ok=True)
+            os.chmod(path, 0o755)
+            
+            # Verify the directory is at least readable
+            if not os.access(path, os.R_OK | os.W_OK):
+                raise Exception(f"Cannot read/write to directory: {path}")
+                
+        except Exception as nested_e:
+            raise Exception(f"Could not create or set permissions for {path}: {str(nested_e)}")
+            
+    return path
 
 # Create necessary directories with full permissions
 ensure_directory(log_dir)
@@ -262,7 +290,6 @@ def compute_answers():
             
             # Clean up PDF directory
             try:
-                import shutil
                 shutil.rmtree(pdf_dir)
             except Exception as e:
                 log_print(f"Warning: Could not clean up PDF directory: {e}", "WARNING")
@@ -364,9 +391,17 @@ def compute_marks():
                 "message": message
             }), 400
 
-        # Create a temporary directory for processing
-        base_temp_dir = tempfile.mkdtemp()
-        log_print(f"Created temporary directory: {base_temp_dir}")
+        # Create a temporary directory with proper permissions
+        try:
+            base_temp_dir = os.path.join(BASE_DIR, 'temp_processing')
+            ensure_directory(base_temp_dir)
+            log_print(f"Created temporary directory: {base_temp_dir}")
+        except Exception as e:
+            log_print(f"Error creating temp directory: {str(e)}", "ERROR")
+            return jsonify({
+                "error": "Server error",
+                "message": "Could not create temporary directory"
+            }), 500
         
         # Dictionary to store results by student folder and image name
         results = {}
@@ -407,74 +442,94 @@ def compute_marks():
                         results[student_folder] = {}
                         log_print(f"Initialized results for student: {student_folder}")
                         
-                    # Save and process file
-                    student_dir = os.path.join(base_temp_dir, student_folder)
-                    os.makedirs(student_dir, exist_ok=True)
-                    filepath = os.path.join(student_dir, filename)
-                    
-                    # Ensure filepath is secure
-                    filepath = secure_filename(filepath)
-                    file.save(filepath)
-                    log_print(f"Saved file to: {filepath}")
-                    
-                    # Extract text
-                    extracted_text = extract_text_from_image(filepath)
-                    if not extracted_text:
-                        log_print(f"No text extracted from: {filepath}", "WARNING")
-                        failed_files.append({
-                            "file": file.filename,
-                            "error": "No text could be extracted from the image"
-                        })
-                        continue
-                    
-                    log_print(f"Extracted text: {extracted_text[:100]}...")
-                    
-                    # Clean the extracted text for JSON
-                    extracted_text = extracted_text.encode('ascii', 'ignore').decode('ascii')
-                    
-                    # Find best matching answer
-                    best_score = 0
-                    best_answer_index = 0
-                    
-                    for i, correct_answer in enumerate(correct_answers):
+                    # Save and process file with proper permissions
+                    try:
+                        student_dir = os.path.join(base_temp_dir, student_folder)
+                        ensure_directory(student_dir)
+                        
+                        # Use a more reliable filename
+                        safe_filename = secure_filename(f"{student_folder}_{filename}")
+                        filepath = os.path.join(student_dir, safe_filename)
+                        
+                        # Save file with proper permissions
+                        file.save(filepath)
+                        os.chmod(filepath, 0o666)  # Make file readable/writable
+                        log_print(f"Saved file to: {filepath}")
+                        
+                        # Extract text
+                        extracted_text = extract_text_from_image(filepath)
+                        
+                        # Clean up the file immediately after processing
                         try:
-                            # Clean the correct answer for comparison
-                            clean_correct_answer = correct_answer.encode('ascii', 'ignore').decode('ascii')
-                            
-                            # Calculate similarity scores
-                            semantic_score = question_vector_sentence(extracted_text, clean_correct_answer)
-                            word_score = question_vector_word(extracted_text, clean_correct_answer)
-                            tfidf_score = tfidf_answer_score(extracted_text, clean_correct_answer, max_tfidf)
-                            ft_score = fasttext_similarity(extracted_text, clean_correct_answer)
-                            llm_marks = llm_score(extracted_text, clean_correct_answer)
-                            
-                            combined_score = (
-                                semantic_score * 0.3 +
-                                word_score * 0.2 +
-                                tfidf_score * 0.2 +
-                                ft_score * 0.2 +
-                                llm_marks * 0.1
-                            )
-                            
-                            log_print(f"Scores for answer {i+1}: semantic={semantic_score}, word={word_score}, tfidf={tfidf_score}, ft={ft_score}, llm={llm_marks}, combined={combined_score}")
+                            os.remove(filepath)
+                        except Exception as e:
+                            log_print(f"Warning: Could not remove temp file {filepath}: {e}", "WARNING")
                             
-                            if combined_score > best_score:
-                                best_score = combined_score
-                                best_answer_index = i
-                                
-                        except Exception as score_error:
-                            error_msg = str(score_error).encode('ascii', 'ignore').decode('ascii')
-                            log_print(f"Error calculating scores for {filepath}: {error_msg}", "ERROR")
+                        if not extracted_text:
+                            log_print(f"No text extracted from: {filepath}", "WARNING")
                             failed_files.append({
                                 "file": file.filename,
-                                "error": f"Error calculating scores: {error_msg}"
+                                "error": "No text could be extracted from the image"
                             })
                             continue
-                    
-                    marks = new_value(best_score, 0, 1, 0, 5)
-                    results[student_folder][filename] = round(marks, 2)
-                    log_print(f"Assigned marks for {filename} in {student_folder}: {marks}")
-                    
+                        
+                        log_print(f"Extracted text: {extracted_text[:100]}...")
+                        
+                        # Clean the extracted text for JSON
+                        extracted_text = extracted_text.encode('ascii', 'ignore').decode('ascii')
+                        
+                        # Find best matching answer
+                        best_score = 0
+                        best_answer_index = 0
+                        
+                        for i, correct_answer in enumerate(correct_answers):
+                            try:
+                                # Clean the correct answer for comparison
+                                clean_correct_answer = correct_answer.encode('ascii', 'ignore').decode('ascii')
+                                
+                                # Calculate similarity scores
+                                semantic_score = question_vector_sentence(extracted_text, clean_correct_answer)
+                                word_score = question_vector_word(extracted_text, clean_correct_answer)
+                                tfidf_score = tfidf_answer_score(extracted_text, clean_correct_answer, max_tfidf)
+                                ft_score = fasttext_similarity(extracted_text, clean_correct_answer)
+                                llm_marks = llm_score(extracted_text, clean_correct_answer)
+                                
+                                combined_score = (
+                                    semantic_score * 0.3 +
+                                    word_score * 0.2 +
+                                    tfidf_score * 0.2 +
+                                    ft_score * 0.2 +
+                                    llm_marks * 0.1
+                                )
+                                
+                                log_print(f"Scores for answer {i+1}: semantic={semantic_score}, word={word_score}, tfidf={tfidf_score}, ft={ft_score}, llm={llm_marks}, combined={combined_score}")
+                                
+                                if combined_score > best_score:
+                                    best_score = combined_score
+                                    best_answer_index = i
+                                    
+                            except Exception as score_error:
+                                error_msg = str(score_error).encode('ascii', 'ignore').decode('ascii')
+                                log_print(f"Error calculating scores for {filepath}: {error_msg}", "ERROR")
+                                failed_files.append({
+                                    "file": file.filename,
+                                    "error": f"Error calculating scores: {error_msg}"
+                                })
+                                continue
+                        
+                        marks = new_value(best_score, 0, 1, 0, 5)
+                        results[student_folder][filename] = round(marks, 2)
+                        log_print(f"Assigned marks for {filename} in {student_folder}: {marks}")
+                        
+                    except Exception as e:
+                        error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
+                        log_print(f"Error processing file {file.filename}: {error_msg}", "ERROR")
+                        failed_files.append({
+                            "file": file.filename,
+                            "error": error_msg
+                        })
+                        continue
+                        
                 except Exception as e:
                     error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
                     log_print(f"Error processing file {file.filename}: {error_msg}", "ERROR")