Update app.py

app.py

@@ -1,8 +1,8 @@
 import os
 import sqlite3
 import hashlib
-import cv2
 import numpy as np
+import cv2
 from PIL import Image
 import pytesseract
 from pdf2image import convert_from_bytes
@@ -11,10 +11,6 @@ from datetime import datetime
 from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
 import gradio as gr
-import tempfile
-import shutil
-
-# --------- CLASS DEFINITION ---------
 
 class InvoiceDuplicateDetector:
     def __init__(self, db_path="invoices.db"):
@@ -85,8 +81,7 @@ class InvoiceDuplicateDetector:
 
     def calculate_text_similarity(self, text1, text2):
         try:
-            if not text1.strip() or not text2.strip(): 
-                return 0
+            if not text1.strip() or not text2.strip(): return 0
             tfidf = self.vectorizer.fit_transform([text1, text2])
             return cosine_similarity(tfidf[0:1], tfidf[1:2])[0][0]
         except:
@@ -95,11 +90,7 @@ class InvoiceDuplicateDetector:
     def hamming_distance(self, h1, h2):
         return sum(c1 != c2 for c1, c2 in zip(h1, h2)) if len(h1) == len(h2) else float('inf')
 
-    def store_invoice_from_path(self, file_path, filename):
-        """Store invoice from file path (for Gradio compatibility)"""
-        with open(file_path, 'rb') as f:
-            file_bytes = f.read()
-        
+    def store_invoice(self, file_bytes, filename):
         file_hash = self.calculate_file_hash(file_bytes)
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
@@ -115,7 +106,6 @@ class InvoiceDuplicateDetector:
             else:
                 image = np.array(Image.open(BytesIO(file_bytes)).convert('RGB'))
         except Exception as e:
-            conn.close()
             return False, f"Error processing file: {str(e)}"
 
         image_hash = self.calculate_image_hash(image)
@@ -130,21 +120,15 @@ class InvoiceDuplicateDetector:
         conn.close()
         return True, "Stored successfully."
 
-    def find_duplicates_from_path(self, file_path, threshold=0.8):
-        """Find duplicates from file path (for Gradio compatibility)"""
-        with open(file_path, 'rb') as f:
-            file_bytes = f.read()
-        
-        filename = os.path.basename(file_path)
+    def find_duplicates(self, file_bytes, filename, threshold=0.8):
         ext = filename.lower().split('.')[-1]
-        
         try:
             if ext == 'pdf':
                 image = self.pdf_to_image(file_bytes)
             else:
                 image = np.array(Image.open(BytesIO(file_bytes)).convert('RGB'))
         except Exception as e:
-            return False, f"Failed to process file: {str(e)}", None, []
+            return False, f"Failed to process file: {str(e)}"
 
         image_hash = self.calculate_image_hash(image)
         extracted_text = self.extract_text_from_image(image)
@@ -156,8 +140,6 @@ class InvoiceDuplicateDetector:
         conn.close()
 
         results = []
-        matched_images = []
-        
         for inv in invoices:
             iid, fname, stored_hash, stored_text, blob = inv
             stored_image = np.array(self.blob_to_image(blob).convert('RGB'))
@@ -165,146 +147,60 @@ class InvoiceDuplicateDetector:
             text_similarity = self.calculate_text_similarity(extracted_text, stored_text)
             img_similarity = self.calculate_image_similarity(image, stored_image)
             combined = 0.4 * hash_similarity + 0.4 * text_similarity + 0.2 * img_similarity
-            
             if combined >= threshold:
                 results.append((fname, combined))
-                matched_images.append(stored_image)
-        
-        # Sort by similarity score
-        if results:
-            sorted_results = sorted(zip(results, matched_images), key=lambda x: x[0][1], reverse=True)
-            results = [r[0] for r in sorted_results]
-            matched_images = [r[1] for r in sorted_results]
-        
-        return True, "Search completed", image, results, matched_images
+        results.sort(key=lambda x: x[1], reverse=True)
+        return True, results
 
-# --------- GRADIO INTERFACE FUNCTIONS ---------
 
-# Initialize detector
 detector = InvoiceDuplicateDetector()
 
-def upload_and_store_invoices(files):
-    """Handle multiple file uploads and store them"""
+def upload_files(files):
     if not files:
         return "No files uploaded."
-    
     results = []
     for file in files:
-        filename = os.path.basename(file.name)
-        success, msg = detector.store_invoice_from_path(file.name, filename)
-        status = "✅" if success else "❌"
-        results.append(f"{status} {filename}: {msg}")
-    
+        try:
+            with open(file.path, "rb") as f:
+                file_bytes = f.read()
+            filename = file.name
+            success, message = detector.store_invoice(file_bytes, filename)
+            results.append(f"{filename}: {message}")
+        except Exception as e:
+            results.append(f"{getattr(file, 'name', 'unknown')}: File read error: {str(e)}")
     return "\n".join(results)
 
-def check_for_duplicates(file, threshold):
-    """Check uploaded file for duplicates"""
-    if not file:
-        return "No file uploaded.", None, "No duplicates found."
-    
-    filename = os.path.basename(file.name)
-    success, msg, input_image, results, matched_images = detector.find_duplicates_from_path(
-        file.name, threshold=threshold/100.0
-    )
-    
-    if not success:
-        return f"Error: {msg}", None, "Error occurred during processing."
-    
-    if not results:
-        return "✅ No duplicates found!", input_image, "No similar invoices found in the database."
-    
-    # Format results
-    duplicate_info = f"⚠️ Found {len(results)} potential duplicate(s):\n\n"
-    for i, (fname, score) in enumerate(results):
-        duplicate_info += f"{i+1}. **{fname}** - Similarity: {score:.2%}\n"
-    
-    # Return the first matched image for display
-    first_match = matched_images[0] if matched_images else None
-    
-    return duplicate_info, input_image, f"Showing match: {results[0][0]} (Similarity: {results[0][1]:.2%})" if results else "No matches"
-
-def get_database_stats():
-    """Get statistics about stored invoices"""
-    conn = sqlite3.connect(detector.db_path)
-    cursor = conn.cursor()
-    cursor.execute("SELECT COUNT(*) FROM invoices")
-    count = cursor.fetchone()[0]
-    conn.close()
-    return f"📊 Database contains {count} stored invoices"
-
-# --------- GRADIO INTERFACE ---------
-
-with gr.Blocks(title="Invoice Duplicate Detector", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 📄 Invoice Duplicate Detector")
-    gr.Markdown("Upload invoices to store them in the database, then check new invoices for potential duplicates.")
-    
-    with gr.Tab("📤 Upload & Store Invoices"):
-        gr.Markdown("### Upload invoice files to store in the database")
-        upload_files = gr.File(
-            label="Select invoice files (PDF, PNG, JPG, JPEG)",
-            file_count="multiple",
-            file_types=[".pdf", ".png", ".jpg", ".jpeg"]
-        )
-        upload_btn = gr.Button("Store Invoices", variant="primary")
-        upload_output = gr.Textbox(label="Upload Results", lines=5)
-        
-        upload_btn.click(
-            fn=upload_and_store_invoices,
-            inputs=upload_files,
-            outputs=upload_output
-        )
-    
-    with gr.Tab("🔍 Check for Duplicates"):
-        gr.Markdown("### Upload a file to check for duplicates")
-        
-        with gr.Row():
-            with gr.Column():
-                check_file = gr.File(
-                    label="Upload file to check",
-                    file_types=[".pdf", ".png", ".jpg", ".jpeg"]
-                )
-                threshold_slider = gr.Slider(
-                    minimum=50,
-                    maximum=100,
-                    value=80,
-                    step=5,
-                    label="Similarity Threshold (%)",
-                    info="Higher values = stricter matching"
-                )
-                check_btn = gr.Button("Check for Duplicates", variant="primary")
-        
-        duplicate_results = gr.Textbox(label="Duplicate Check Results", lines=5)
-        
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("#### Input Invoice")
-                input_image = gr.Image(label="Uploaded Invoice")
-            with gr.Column():
-                gr.Markdown("#### Best Match")
-                match_image = gr.Image(label="Matched Invoice")
-        
-        match_info = gr.Textbox(label="Match Information")
-        
-        check_btn.click(
-            fn=check_for_duplicates,
-            inputs=[check_file, threshold_slider],
-            outputs=[duplicate_results, input_image, match_info]
-        )
-    
-    with gr.Tab("📊 Database Info"):
-        gr.Markdown("### Database Statistics")
-        stats_btn = gr.Button("Refresh Stats")
-        stats_output = gr.Textbox(label="Database Statistics")
-        
-        stats_btn.click(
-            fn=get_database_stats,
-            outputs=stats_output
-        )
-        
-        # Load stats on page load
-        app.load(fn=get_database_stats, outputs=stats_output)
+def check_duplicates(file):
+    try:
+        with open(file.path, "rb") as f:
+            file_bytes = f.read()
+        filename = file.name
+        ok, result = detector.find_duplicates(file_bytes, filename)
+        if not ok:
+            return result
+        if not result:
+            return "✅ No duplicates found!"
+        return "\n".join([f"🔁 {fname} — Similarity: {score:.2f}" for fname, score in result])
+    except Exception as e:
+        return f"File read error: {str(e)}"
+
+with gr.Blocks(theme=gr.themes.Base()) as demo:
+    gr.Markdown("## 📄 Invoice Duplicate Detector")
+
+    with gr.Row():
+        with gr.Column():
+            upload_input = gr.File(file_types=[".pdf", ".png", ".jpg", ".jpeg"], file_count="multiple", label="Upload Invoices")
+            upload_btn = gr.Button("Upload")
+            upload_output = gr.Textbox(label="Upload Result")
+        with gr.Column():
+            check_input = gr.File(file_types=[".pdf", ".png", ".jpg", ".jpeg"], label="Check for Duplicate")
+            check_btn = gr.Button("Check")
+            check_output = gr.Textbox(label="Check Result")
+
+    upload_btn.click(upload_files, inputs=upload_input, outputs=upload_output)
+    check_btn.click(check_duplicates, inputs=check_input, outputs=check_output)
+
+demo.launch()
 
-if __name__ == "__main__":
-    app.launch()