Update app.py

app.py

@@ -18,20 +18,22 @@ 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')
+# Model and data paths - Hugging Face assumes these are in the root directory
+MODEL_CLASSIFICATION_PATH = "classification.pt"  
+MODEL_DETECTION_PATH = "detection.pt"  
+
+# Load YOLOv8 models
 try:
-    classifier = YOLO(os.path.join(MODEL_DIR, "classification.pt"))
-    detector = YOLO(os.path.join(MODEL_DIR, "detection.pt"))
+    classifier = YOLO(MODEL_CLASSIFICATION_PATH)
+    detector = YOLO(MODEL_DETECTION_PATH)
 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
+# Initialize EasyOCR 
 try:
-    reader = Reader(['en'])
+    reader = Reader(['en']) 
 except Exception as e:
     print(f"EasyOCR initialization error: {e}")
     reader = None
@@ -269,11 +271,12 @@ def about():
 def contact():
     return render_template('contact.html')
 
-@app.route('/upload', methods=['POST'])
+@app.route('/', methods=['GET', 'POST'])
 def upload_files():
-    try:
+    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 files are required."}), 400
+            return jsonify({"error": "Both zipfile and excelfile are required."}), 400
 
         zip_file = request.files['zipfile']
         excel_file = request.files['excelfile']
@@ -282,85 +285,51 @@ def upload_files():
         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)
-
-        # Ensure directories exist
-        os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-        os.makedirs(app.config['RESULTS_FOLDER'], exist_ok=True)
-
-        # Save files with error handling
         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)
-        except Exception as e:
-            return jsonify({"error": f"File save error: {str(e)}"}), 500
 
-        # Extract zip with error handling
-        try:
+            # Extract zip
             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
-
-        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:
+                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)
+            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', 
+                comparison_results['Final Remarks'] == 'All matched',
+                'Accepted',
                 'Rejected'
             )
 
-            # Save results
+            # Prepare for download - adjust path if needed
             results_df = pd.DataFrame(comparison_results)
-            results_file_path = os.path.join(app.config['RESULTS_FOLDER'], 'results.xlsx')
+            results_file_path = '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)
+            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!", 
+                "message": "Files processed successfully!",
                 "results": comparison_results[
                     ['SrNo', 'Document Type', 'Accepted/Rejected', 'Final Remarks']
                 ].to_dict(orient='records'),
@@ -368,21 +337,21 @@ def upload_files():
             })
 
         except Exception as e:
-            return jsonify({"error": f"Excel processing error: {str(e)}"}), 500
+            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)
 
-    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)}")
+    else: # GET request
+        return render_template("services.html")
 
 if __name__ == '__main__':
     # Configure HTTPS with self-signed certificate
-    app.run(host='0.0.0.0', port=7860) 
+    app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 7680)))