Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import os | |
| import pandas as pd | |
| import shutil | |
| import sys | |
| # --------------------------------------------------------- | |
| # IMPORT LOGICCODE | |
| # --------------------------------------------------------- | |
| # We expect logiccode.py to be in the same directory | |
| try: | |
| import logiccode | |
| except ImportError as e: | |
| print("CRITICAL ERROR: Could not import 'logiccode.py'.") | |
| print(f"Ensure logiccode.py is in the same directory as app.py. Error: {e}") | |
| sys.exit(1) | |
| # --------------------------------------------------------- | |
| # MOCK ARGUMENTS | |
| # --------------------------------------------------------- | |
| # This class mimics the argparse object that logiccode expects | |
| class MockArgs: | |
| def __init__(self): | |
| self.debug = False | |
| self.pages = 3 | |
| self.file = [] | |
| self.inputkeywords = "" | |
| self.required = [] | |
| self.fuzzy = True | |
| self.visualize = False | |
| # Initialize args in logiccode if not already present | |
| if not hasattr(logiccode, 'args'): | |
| logiccode.args = MockArgs() | |
| # --------------------------------------------------------- | |
| # CORE PROCESSING FUNCTION | |
| # --------------------------------------------------------- | |
| def process_documents(files, keywords_input, required_docs, fuzzy_match_enabled, debug_enabled): | |
| """ | |
| Process uploaded files using the imported logiccode module. | |
| """ | |
| # 1. Update global args in logiccode based on UI inputs | |
| logiccode.args.debug = debug_enabled | |
| logiccode.args.fuzzy = fuzzy_match_enabled | |
| # Initialize output containers | |
| results = [] | |
| gallery_images = [] | |
| logs = [] | |
| # Parse keywords | |
| user_keywords = [kw.strip() for kw in keywords_input.split() if kw.strip()] | |
| # Track found documents for "Required" check | |
| found_documents = set() | |
| all_matched_keywords_per_file = [] | |
| if not files: | |
| return "<h3>⚠️ No files uploaded</h3>", [], pd.DataFrame(), "Please upload files to begin." | |
| logs.append(f"Starting processing of {len(files)} files...") | |
| logs.append(f"Target Keywords: {user_keywords}") | |
| logs.append(f"Required Documents: {required_docs}") | |
| # 2. Iterate through uploaded files | |
| for file_obj in files: | |
| file_path = file_obj.name | |
| filename = os.path.basename(file_path) | |
| logs.append(f"\n--- Processing: {filename} ---") | |
| # --- A. Generate Previews for Gallery --- | |
| if file_path.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff')): | |
| gallery_images.append((file_path, filename)) | |
| elif file_path.lower().endswith('.pdf'): | |
| try: | |
| # Use logiccode's utility to get a preview of the 1st page | |
| preview_pages, _, _ = logiccode.pdf_to_images(file_path, max_pages=1) | |
| if preview_pages: | |
| gallery_images.append((preview_pages[0], f"{filename} (PDF Preview)")) | |
| logs.append(f"Generated PDF preview for {filename}") | |
| except Exception as e: | |
| logs.append(f"⚠️ PDF Preview failed for {filename}: {e}") | |
| # --- B. Text Extraction & Analysis --- | |
| try: | |
| # Extract text (logiccode handles PDF vs Image internally) | |
| ocr_texts = logiccode.get_ocr_text(file_path, logiccode.args.pages) | |
| if not ocr_texts: | |
| logs.append(f"⚠️ Warning: No text extracted from {filename}") | |
| results.append({ | |
| "File": filename, "Type": "Unreadable", "Score": 0, | |
| "Status": "FAILED", "Matched Keywords": "" | |
| }) | |
| continue | |
| # Normalize text | |
| full_text = " ".join(ocr_texts) | |
| ocr_tokens = logiccode.normalize_text(full_text) | |
| # Classify Document | |
| doc_type, doc_score = logiccode.calculate_doc_type(ocr_tokens, debug=debug_enabled) | |
| found_documents.add(doc_type) | |
| logs.append(f"Classified as: {doc_type} (Confidence: {doc_score:.1f}%)") | |
| # Verify Keywords | |
| # logiccode.verify_keywords returns [{'keyword': 'x', 'matched': True/False, ...}] | |
| verification_results = logiccode.verify_keywords(ocr_tokens, user_keywords, fuzzy_match_enabled) | |
| matched_kws = [r['keyword'] for r in verification_results if r['matched']] | |
| all_matched_keywords_per_file.append(set(matched_kws)) | |
| # Determine File Status | |
| # If keywords were provided, we require all of them to match for "VERIFIED" | |
| if user_keywords: | |
| file_status = "VERIFIED" if len(matched_kws) == len(user_keywords) else "PARTIAL" | |
| if len(matched_kws) == 0: file_status = "FAILED" | |
| else: | |
| file_status = "INFO ONLY" | |
| logs.append(f"Matched: {matched_kws if matched_kws else 'None'}") | |
| results.append({ | |
| "File": filename, | |
| "Type": doc_type, | |
| "Score": f"{doc_score:.1f}%", | |
| "Status": file_status, | |
| "Matched Keywords": ", ".join(matched_kws) | |
| }) | |
| except Exception as e: | |
| error_msg = f"Error processing {filename}: {str(e)}" | |
| logs.append(error_msg) | |
| if debug_enabled: | |
| import traceback | |
| logs.append(traceback.format_exc()) | |
| results.append({ | |
| "File": filename, "Type": "Error", "Score": 0, | |
| "Status": "ERROR", "Matched Keywords": str(e) | |
| }) | |
| # 3. Calculate Summary Logic | |
| required_set = set(required_docs) | |
| missing_docs = required_set - found_documents | |
| all_user_keywords = set(user_keywords) | |
| keywords_found_across_all_files = set() | |
| for file_kw_set in all_matched_keywords_per_file: | |
| keywords_found_across_all_files.update(file_kw_set) | |
| missing_keywords = all_user_keywords - keywords_found_across_all_files | |
| # 4. Build HTML Report | |
| return build_html_summary(required_set, missing_docs, missing_keywords), gallery_images, pd.DataFrame(results), "\n".join(logs) | |
| def build_html_summary(required_set, missing_docs, missing_keywords): | |
| html = """ | |
| <div style='padding: 20px; background-color: white; border-radius: 10px; border: 1px solid #e5e7eb;'> | |
| <h3 style='margin-top: 0; color: #333;'>Verification Summary</h3> | |
| """ | |
| # Document Status | |
| doc_status_bool = True | |
| if required_set: | |
| if missing_docs: | |
| doc_status_bool = False | |
| html += f"<div style='margin-bottom: 8px;'>❌ <b>Missing Documents:</b> <span style='color: #ef4444;'>{', '.join(sorted(missing_docs))}</span></div>" | |
| else: | |
| html += f"<div style='margin-bottom: 8px;'>✅ <b>Documents:</b> All required types found.</div>" | |
| else: | |
| html += "<div style='margin-bottom: 8px; color: #666;'>ℹ️ No specific document types required.</div>" | |
| # Keyword Status | |
| kw_status_bool = True | |
| if missing_keywords: | |
| kw_status_bool = False | |
| html += f"<div style='margin-bottom: 8px;'>❌ <b>Missing Keywords:</b> <span style='color: #ef4444;'>{', '.join(sorted(missing_keywords))}</span></div>" | |
| else: | |
| html += f"<div style='margin-bottom: 8px;'>✅ <b>Keywords:</b> All keywords found.</div>" | |
| # Final Status | |
| overall_color = "#10b981" if (doc_status_bool and kw_status_bool) else "#ef4444" | |
| overall_text = "VERIFIED" if (doc_status_bool and kw_status_bool) else "ACTION REQUIRED" | |
| html += f"<hr style='margin: 15px 0; border-color: #eee;'>" | |
| html += f"<h2 style='color: {overall_color}; margin: 0; text-align: center;'>{overall_text}</h2>" | |
| html += "</div>" | |
| return html | |
| # --------------------------------------------------------- | |
| # GRADIO UI SETUP | |
| # --------------------------------------------------------- | |
| theme = gr.themes.Soft( | |
| primary_hue="blue", | |
| secondary_hue="slate", | |
| ).set( | |
| body_background_fill="#f9fafb", | |
| block_background_fill="white", | |
| block_border_width="1px" | |
| ) | |
| with gr.Blocks(theme=theme, title="DocuVerify Pro") as demo: | |
| gr.Markdown( | |
| """ | |
| # 📄 Intelligent Document Verification | |
| Upload documents, specify required types, and verify content matches automatically. | |
| """ | |
| ) | |
| with gr.Row(): | |
| # Left Column: Inputs | |
| with gr.Column(scale=4): | |
| files_input = gr.File( | |
| file_count="multiple", | |
| label="1. Upload Documents", | |
| file_types=[".pdf", ".png", ".jpg", ".jpeg", ".bmp"], | |
| height=250 | |
| ) | |
| keywords_input = gr.Textbox( | |
| label="2. Keywords to Verify", | |
| placeholder="Name, ID Number, Date of Birth...", | |
| info="Enter values that MUST appear in the documents (space separated)", | |
| lines=2 | |
| ) | |
| # Right Column: Configuration | |
| with gr.Column(scale=3): | |
| # Fetch doc types dynamically from logiccode | |
| available_types = sorted(list(logiccode.DOC_KEYWORDS.keys())) if hasattr(logiccode, 'DOC_KEYWORDS') else [] | |
| required_docs_input = gr.Dropdown( | |
| choices=available_types, | |
| multiselect=True, | |
| label="3. Required Document Types", | |
| info="Which documents are mandatory?", | |
| value=[] | |
| ) | |
| with gr.Group(): | |
| gr.Markdown("### Settings") | |
| fuzzy_checkbox = gr.Checkbox(value=True, label="Enable Fuzzy Matching (Approximate spelling)") | |
| debug_checkbox = gr.Checkbox(value=False, label="Show Debug Logs") | |
| verify_btn = gr.Button("🔍 Verify Documents", variant="primary", size="lg") | |
| gr.Markdown("---") | |
| # Results Area | |
| with gr.Row(): | |
| # Summary Box | |
| with gr.Column(scale=1): | |
| status_output = gr.HTML(label="Overall Status") | |
| # Detailed Tabs | |
| with gr.Column(scale=2): | |
| with gr.Tabs(): | |
| with gr.TabItem("📊 Results Table"): | |
| results_df = gr.Dataframe( | |
| headers=["File", "Type", "Score", "Status", "Matched Keywords"], | |
| interactive=False | |
| ) | |
| with gr.TabItem("🖼️ Document Gallery"): | |
| gallery = gr.Gallery( | |
| label="Processed Images", | |
| show_label=False, | |
| columns=[3], rows=[2], | |
| object_fit="contain", | |
| height="auto" | |
| ) | |
| with gr.TabItem("📝 System Logs"): | |
| logs_output = gr.Textbox( | |
| label="Processing Logs", | |
| lines=15, | |
| interactive=False, | |
| show_copy_button=True | |
| ) | |
| # Event Trigger | |
| verify_btn.click( | |
| fn=process_documents, | |
| inputs=[files_input, keywords_input, required_docs_input, fuzzy_checkbox, debug_checkbox], | |
| outputs=[status_output, gallery, results_df, logs_output] | |
| ) | |
| if __name__ == "__main__": | |
| # Increase max file size if needed, allow sharing | |
| demo.launch(share=False, server_name="0.0.0.0") |