Update app.py

app.py

@@ -1,8 +1,8 @@
 import os
 import sqlite3
 import hashlib
-import numpy as np
 import cv2
+import numpy as np
 from PIL import Image
 import pytesseract
 from pdf2image import convert_from_bytes
@@ -11,6 +11,10 @@ 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"):
@@ -81,7 +85,8 @@ 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:
@@ -90,7 +95,11 @@ 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(self, file_bytes, filename):
+    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()
+        
         file_hash = self.calculate_file_hash(file_bytes)
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
@@ -106,6 +115,7 @@ 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)
@@ -120,15 +130,21 @@ class InvoiceDuplicateDetector:
         conn.close()
         return True, "Stored successfully."
 
-    def find_duplicates(self, file_bytes, filename, threshold=0.8):
+    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)
         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)}"
+            return False, f"Failed to process file: {str(e)}", None, []
 
         image_hash = self.calculate_image_hash(image)
         extracted_text = self.extract_text_from_image(image)
@@ -140,6 +156,8 @@ 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'))
@@ -147,57 +165,146 @@ 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))
-        results.sort(key=lambda x: x[1], reverse=True)
-        return True, results
+                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
 
+# --------- GRADIO INTERFACE FUNCTIONS ---------
 
+# Initialize detector
 detector = InvoiceDuplicateDetector()
 
-def upload_files(files):
+def upload_and_store_invoices(files):
+    """Handle multiple file uploads and store them"""
     if not files:
         return "No files uploaded."
+    
     results = []
     for file in files:
-        try:
-            file_bytes = file.read()
-            filename = getattr(file, "name", "uploaded")
-            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)}")
+        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}")
+    
     return "\n".join(results)
 
-def check_duplicates(file):
-    try:
-        file_bytes = file.read()
-        filename = getattr(file, "name", "uploaded")
-        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()
+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)
+
+if __name__ == "__main__":
+    app.launch()