Update app.py

app.py

@@ -11,28 +11,58 @@ import numpy as np
 import json
 import sqlite3
 
+# Ensure directories exist and are absolute
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+UPLOAD_FOLDER = os.path.join(BASE_DIR, 'uploads')
+RESULTS_FOLDER = os.path.join(BASE_DIR, 'results')
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(RESULTS_FOLDER, exist_ok=True)
+
+# Load models with full path or from environment
+MODEL_DIR = os.path.join(BASE_DIR, 'models')
+try:
+    classifier = YOLO(os.path.join(MODEL_DIR, "classification.pt"))
+    detector = YOLO(os.path.join(MODEL_DIR, "detection.pt"))
+except Exception as e:
+    print(f"Model loading error: {e}")
+    # Fallback mechanism or alternative model loading
+    classifier = None
+    detector = None
+
+# Initialize EasyOCR with error handling
+try:
+    reader = Reader(['en'])
+except Exception as e:
+    print(f"EasyOCR initialization error: {e}")
+    reader = None
+
 app = Flask(__name__)
-app.config['UPLOAD_FOLDER'] = './uploads/'
-app.config['ALLOWED_EXTENSIONS'] = {'zip', 'xlsx'}
-app.config['RESULTS_FOLDER'] = './results/'
-
-classifier = YOLO("./models/classification.pt")
-detector = YOLO("./models/detection.pt")
-reader = Reader(['en'])
-
-def process_image(image_path):
-    if classifier.predict(image_path)[0].probs.numpy().top1 == 0:
-        fields = detector(image_path)
-        image = cv2.imread(image_path)
-        extracted_data = {}
-        for field in fields[0].boxes.data.tolist():
-            x1, y1, x2, y2, confidence, class_id = map(int, field[:6])
-            field_class = detector.names[class_id]
-            cropped_roi = image[y1:y2, x1:x2]
-            gray_roi = cv2.cvtColor(cropped_roi, cv2.COLOR_BGR2GRAY)
-            text = reader.readtext(gray_roi, detail=0)
-            extracted_data[field_class] = ' '.join(text)
-        return extracted_data
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['RESULTS_FOLDER'] = RESULTS_FOLDER
+
+def safe_process_image(image_path):
+    """Safe image processing with extensive error handling"""
+    try:
+        if not classifier or not detector or not reader:
+            raise ValueError("Models not properly initialized")
+        
+        classification_result = classifier.predict(image_path)[0]
+        if classification_result.probs.numpy().top1 == 0:
+            fields = detector(image_path)
+            image = cv2.imread(image_path)
+            extracted_data = {}
+            
+            for field in fields[0].boxes.data.tolist():
+                x1, y1, x2, y2, confidence, class_id = map(int, field[:6])
+                field_class = detector.names[class_id]
+                cropped_roi = image[y1:y2, x1:x2]
+                gray_roi = cv2.cvtColor(cropped_roi, cv2.COLOR_BGR2GRAY)
+                text = reader.readtext(gray_roi, detail=0)
+                extracted_data[field_class] = ' '.join(text)
+            
+            return extracted_data
+    except Exception as e:
+        print(f"Image processing error: {e}")
     return None
 
 # Helper Functions
@@ -241,58 +271,118 @@ def contact():
 
 @app.route('/upload', methods=['POST'])
 def upload_files():
-    if 'zipfile' in request.files and 'excelfile' in request.files:
+    try:
+        if 'zipfile' not in request.files or 'excelfile' not in request.files:
+            return jsonify({"error": "Both files are required."}), 400
+
         zip_file = request.files['zipfile']
         excel_file = request.files['excelfile']
 
-        # Save files
+        # Validate file types
+        if not zip_file.filename.endswith('.zip') or not excel_file.filename.endswith('.xlsx'):
+            return jsonify({"error": "Invalid file formats. Need .zip and .xlsx files."}), 400
+
+        # Create absolute paths
         zip_path = os.path.join(app.config['UPLOAD_FOLDER'], zip_file.filename)
         excel_path = os.path.join(app.config['UPLOAD_FOLDER'], excel_file.filename)
-        zip_file.save(zip_path)
-        excel_file.save(excel_path)
-
-        # Unzip and process images
-        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-            zip_ref.extractall(app.config['UPLOAD_FOLDER'])
 
-        image_paths = [os.path.join(app.config['UPLOAD_FOLDER'], f) for f in os.listdir(app.config['UPLOAD_FOLDER']) if f.endswith(('.jpg', '.png'))]
-        processed_results = {}
-
-        for image_path in image_paths:
-            file_name = os.path.basename(image_path)
-            key = file_name.split('.')[0][:3]
-            if key not in processed_results:  # Check if key already exists
-                extracted_data = process_image(image_path)
-                if extracted_data:
-                    processed_results[key] = extracted_data
-
-        # Read Excel and compare data
-        df = pd.read_excel(excel_path)
-        df = df.astype('str')
-        comparison_results = compare_data(df, processed_results)
-        comparison_results['Accepted/Rejected'] = np.where(comparison_results['Final Remarks'] == 'All matched', 'Accepted', 'Rejected')
-
-        # Save results to a new Excel file
-        results_df = pd.DataFrame(comparison_results)
+        # Ensure directories exist
+        os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
         os.makedirs(app.config['RESULTS_FOLDER'], exist_ok=True)
-        results_file_path = os.path.join(app.config['RESULTS_FOLDER'], 'results.xlsx')
-        results_df.to_excel(results_file_path, index=False)
-
-        visualization_data = create_visualizations(comparison_results)
 
-        create_database_and_table() # Ensure database and table exist
-        save_results_to_database(comparison_results[
-                        ['SrNo', 'Document Type', 'Accepted/Rejected', 'Final Remarks']
-                    ].to_dict(orient='records'))
+        # Save files with error handling
+        try:
+            zip_file.save(zip_path)
+            excel_file.save(excel_path)
+        except Exception as e:
+            return jsonify({"error": f"File save error: {str(e)}"}), 500
+
+        # Extract zip with error handling
+        try:
+            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                zip_ref.extractall(app.config['UPLOAD_FOLDER'])
+        except zipfile.BadZipFile:
+            return jsonify({"error": "Invalid or corrupted zip file"}), 400
+
+        # Process images with memory management
+        image_paths = [os.path.join(app.config['UPLOAD_FOLDER'], f) 
+                      for f in os.listdir(app.config['UPLOAD_FOLDER']) 
+                      if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
+        
+        if not image_paths:
+            return jsonify({"error": "No valid images found in zip file"}), 400
 
-        return jsonify({"message": "Files processed successfully!", 
-                    "results": comparison_results[
-                        ['SrNo', 'Document Type', 'Accepted/Rejected', 'Final Remarks']
-                    ].to_dict(orient='records'),
-                    "visualization_data": visualization_data})  
-
-    return jsonify({"error": "Both files are required."}), 400
+        processed_results = {}
+        for image_path in image_paths:
+            try:
+                file_name = os.path.basename(image_path)
+                key = file_name.split('.')[0][:3]
+                if key not in processed_results:
+                    extracted_data = process_image(image_path)
+                    if extracted_data:
+                        processed_results[key] = extracted_data
+                # Clean up processed image
+                if os.path.exists(image_path):
+                    os.remove(image_path)
+            except Exception as e:
+                print(f"Error processing image {image_path}: {str(e)}")
+                continue
+
+        # Process Excel with error handling
+        try:
+            df = pd.read_excel(excel_path)
+            df = df.astype(str)
+            comparison_results = compare_data(df, processed_results)
+            comparison_results['Accepted/Rejected'] = np.where(
+                comparison_results['Final Remarks'] == 'All matched', 
+                'Accepted', 
+                'Rejected'
+            )
+
+            # Save results
+            results_df = pd.DataFrame(comparison_results)
+            results_file_path = os.path.join(app.config['RESULTS_FOLDER'], 'results.xlsx')
+            results_df.to_excel(results_file_path, index=False)
+
+            visualization_data = create_visualizations(comparison_results)
+
+            # Database operations with error handling
+            try:
+                create_database_and_table()
+                save_results_to_database(comparison_results[
+                    ['SrNo', 'Document Type', 'Accepted/Rejected', 'Final Remarks']
+                ].to_dict(orient='records'))
+            except Exception as e:
+                print(f"Database operation error: {str(e)}")
+
+            # Clean up input files
+            os.remove(zip_path)
+            os.remove(excel_path)
+
+            return jsonify({
+                "message": "Files processed successfully!", 
+                "results": comparison_results[
+                    ['SrNo', 'Document Type', 'Accepted/Rejected', 'Final Remarks']
+                ].to_dict(orient='records'),
+                "visualization_data": visualization_data
+            })
+
+        except Exception as e:
+            return jsonify({"error": f"Excel processing error: {str(e)}"}), 500
+
+    except Exception as e:
+        return jsonify({"error": f"General processing error: {str(e)}"}), 500
+
+    finally:
+        # Cleanup any remaining temporary files
+        for f in os.listdir(app.config['UPLOAD_FOLDER']):
+            try:
+                file_path = os.path.join(app.config['UPLOAD_FOLDER'], f)
+                if os.path.isfile(file_path):
+                    os.remove(file_path)
+            except Exception as e:
+                print(f"Cleanup error: {str(e)}")
 
 if __name__ == '__main__':
     # Configure HTTPS with self-signed certificate
-    app.run()
+    app.run(host='0.0.0.0', port=7860)