Update app.py

app.py

@@ -11,60 +11,29 @@ 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)
-
-# Model and data paths - Hugging Face assumes these are in the root directory
-MODEL_CLASSIFICATION_PATH = "models/classification.pt"  
-MODEL_DETECTION_PATH = "models/detection.pt"  
-
-# Load YOLOv8 models
-try:
-    classifier = YOLO(MODEL_CLASSIFICATION_PATH)
-    detector = YOLO(MODEL_DETECTION_PATH)
-except Exception as e:
-    print(f"Model loading error: {e}")
-    classifier = None
-    detector = None
-
-# Initialize EasyOCR 
-try:
-    reader = Reader(['en']) 
-except Exception as e:
-    print(f"EasyOCR initialization error: {e}")
-    reader = None
-
 app = Flask(__name__)
-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}")
+app.config['UPLOAD_FOLDER'] = 'uploads/'
+app.config['ALLOWED_EXTENSIONS'] = {'zip', 'xlsx'}
+app.config['RESULTS_FOLDER'] = 'results/'
+app.config['DATABASE'] = 'results_ack.db'
+
+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
     return None
 
 # Helper Functions
@@ -249,6 +218,43 @@ def create_visualizations(comparison_results):
 
     return visualization_data
 
+def create_database_and_table():
+    """Creates the database and table if they don't exist."""
+    conn = sqlite3.connect(app.config['DATABASE'])
+    cursor = conn.cursor()
+
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS results (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            SrNo TEXT,
+            DocumentType TEXT,
+            AcceptedRejected TEXT,
+            FinalRemarks TEXT
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def save_results_to_database(results):
+    """Saves the provided results to the SQLite database."""
+    conn = sqlite3.connect(app.config['DATABASE'])
+    cursor = conn.cursor()
+
+    for result in results:
+        cursor.execute('''
+            INSERT INTO results (SrNo, DocumentType, AcceptedRejected, FinalRemarks)
+            VALUES (?, ?, ?, ?)
+        ''', (
+            result.get('SrNo', ''), 
+            result.get('Document Type', ''), 
+            result.get('Accepted/Rejected', ''), 
+            result.get('Final Remarks', '')
+        ))
+    
+    conn.commit()
+    conn.close()
+
+
 
 @app.route('/download', methods=['GET'])
 def download_results():
@@ -271,87 +277,59 @@ def about():
 def contact():
     return render_template('contact.html')
 
-@app.route('/', methods=['GET', 'POST'])
+@app.route('/upload', methods=['POST'])
 def upload_files():
-    if request.method == 'POST':
-        # Check if the post request has the files
-        if 'zipfile' not in request.files or 'excelfile' not in request.files:
-            return jsonify({"error": "Both zipfile and excelfile are required."}), 400
-
+    if 'zipfile' in request.files and 'excelfile' in request.files:
         zip_file = request.files['zipfile']
         excel_file = request.files['excelfile']
 
-        # 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
-
-        try:
-            # Save files temporarily (Hugging Face Spaces has a temporary file system)
-            zip_path = zip_file.filename 
-            excel_path = excel_file.filename
-            zip_file.save(zip_path)
-            excel_file.save(excel_path)
-
-            # Extract zip
-            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-                zip_ref.extractall('.')  
-
-            # Process images
-            image_paths = [f for f in os.listdir('.') if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
-            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)  # Assuming process_image is defined
-                        if extracted_data:
-                            processed_results[key] = extracted_data
-                except Exception as e:
-                    print(f"Error processing image {image_path}: {str(e)}")
-
-            # Process Excel 
-            df = pd.read_excel(excel_path)
-            df = df.astype(str)
-            comparison_results = compare_data(df, processed_results)  # Assuming compare_data is defined
-            comparison_results['Accepted/Rejected'] = np.where(
-                comparison_results['Final Remarks'] == 'All matched',
-                'Accepted',
-                'Rejected'
-            )
-
-            # Prepare for download - adjust path if needed
-            results_df = pd.DataFrame(comparison_results)
-            results_file_path = 'results.xlsx'
-            results_df.to_excel(results_file_path, index=False)
-
-            visualization_data = create_visualizations(comparison_results)  # Assuming create_visualizations is defined
-
-            # For now, return results as JSON, consider a download link for the Excel
-            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"Processing error: {str(e)}"}), 500
-
-        finally:
-            # Clean up temporary files 
-            if os.path.exists(zip_path):
-                os.remove(zip_path)
-            if os.path.exists(excel_path):
-                os.remove(excel_path)
-            for image_path in image_paths:
-                if os.path.exists(image_path):
-                    os.remove(image_path)
-
-    else: # GET request
-        return render_template("services.html")
+        # Save files
+        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)
+        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'))
+
+        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
 
 if __name__ == '__main__':
-    # Configure HTTPS with self-signed certificate
     app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 7680)))