app

app.py

@@ -1,96 +1,160 @@
 import gradio as gr
 from transformers import pipeline
+from PIL import Image
+import pytesseract
 import re
+import json
 
-# Load text classification pipeline
-classifier = pipeline(
-    "text-classification", 
-    model="distilbert-base-uncased-finetuned-sst-2-english"
-)
-
-def process_application(company, monthly_revenue, monthly_expenses, requested_advance, additional_text):
-    # Calculate net income
-    net_income = monthly_revenue - monthly_expenses
-    
-    # Define reasonable request rule for MCA
-    # Reasonable if advance <= 50% of net income and <= 80% of revenue
-    is_reasonable = (
-        (requested_advance <= (net_income * 0.5) if net_income > 0 else False) 
-        and (requested_advance <= (monthly_revenue * 0.8))
-    )
+def clean_ocr_text(raw_text):
+    """Clean OCR text using regex - only for cleaning, not extraction"""
+    # Remove extra whitespace and normalize
+    cleaned = re.sub(r'\s+', ' ', raw_text)
     
-    reasonable_text = (
-        "\nNote: This request is considered reasonable for MCA based on net income and revenue guidelines." 
-        if is_reasonable 
-        else "\nNote: This request exceeds MCA reasonableness guidelines (advance > 50% of net income or > 80% of revenue)."
-    )
+    # Remove common OCR artifacts
+    cleaned = re.sub(r'[^\w\s\.,;:/\-@#$%&*()]', ' ', cleaned)
     
-    # Create application text with qualitative descriptors and reasonable note
-    application_text = f"""
-        Company: {company}
-        Monthly Revenue: ${monthly_revenue:,}
-        Monthly Expenses: ${monthly_expenses:,}
-        Requested Advance: ${requested_advance:,}
-        {reasonable_text}
-        Additional Context: {additional_text or 'No additional context provided.'}
-        """
+    # Normalize common OCR mistakes
+    cleaned = re.sub(r'\b([A-Z])\s+([A-Z])\b', r'\1\2', cleaned)  # Fix split letters
     
-    # Process with classifier
-    result = classifier(application_text)
-    label = result[0]['label']
-    score = result[0]['score']
+    # Clean up date patterns
+    cleaned = re.sub(r'(\d{2})\s*/\s*(\d{2})\s*/\s*(\d{4})', r'\1/\2/\3', cleaned)
     
-    # Rule-based financial checks
-    ratio = monthly_revenue / monthly_expenses if monthly_expenses > 0 else float('inf')
-    advance_coverage = net_income / requested_advance if requested_advance > 0 else float('inf')
+    return cleaned.strip()
+
+def extract_dl_info(image):
+    """
+    Extracts driver's license information from an image file using OCR and AI model processing.
     
-    # Decision logic: Combine sentiment with financial rules
-    if (label == "POSITIVE" and 
-        score > 0.9 and 
-        ratio > 1.2 and 
-        advance_coverage > 1.0 and 
-        is_reasonable):
-        decision = "Approve"
-    else:
-        decision = "Reject"
+    Args:
+        image: PIL Image object from Gradio
     
-    # Output JSON
-    output = {
-        "company": company,
-        "requested_advance": requested_advance,
-        "risk_label": label,
-        "risk_score": score,
-        "revenue_expense_ratio": round(ratio, 2),
-        "advance_coverage": round(advance_coverage, 2),
-        "reasonable_request": is_reasonable,
-        "decision": decision,
-        "additional_context": additional_text or "None"
-    }
+    Returns:
+        tuple: (raw_ocr_text, cleaned_ocr_text, json_result)
+    """
+    try:
+        # Convert Gradio image to RGB
+        if hasattr(image, 'convert'):
+            image = image.convert("RGB")
+        
+        # Use Tesseract OCR to extract text
+        print("Extracting text with Tesseract OCR...")
+        raw_text = pytesseract.image_to_string(image)
+        print(f"Raw OCR text: {raw_text}")
+        
+        # Clean the OCR text using regex (only for cleaning, not extraction)
+        cleaned_text = clean_ocr_text(raw_text)
+        print(f"Cleaned OCR text: {cleaned_text}")
+        
+        # Use AI model to process cleaned OCR text and extract structured information
+        print("Processing cleaned OCR text with AI model...")
+        
+        # Load a text generation pipeline for structured extraction
+        generator = pipeline("text2text-generation", model="google/flan-t5-base")
+        
+        # Create specific prompts for the AI model to extract individual fields
+        name_prompt = f"From this driver's license text, what is the person's full name? Text: {cleaned_text} Answer:"
+        address_prompt = f"From this driver's license text, what is the street address? Text: {cleaned_text} Answer:"
+        license_prompt = f"From this driver's license text, what is the license number (the long number)? Text: {cleaned_text} Answer:"
+        dob_prompt = f"From this driver's license text, what is the date of birth? Text: {cleaned_text} Answer:"
+        exp_prompt = f"From this driver's license text, what is the expiration date? Text: {cleaned_text} Answer:"
+        state_prompt = f"From this driver's license text, what is the state abbreviation? Text: {cleaned_text} Answer:"
+        
+        # Extract each field separately using AI
+        try:
+            name_result = generator(name_prompt, max_length=50, do_sample=False)
+            name = name_result[0]['generated_text'].strip()
+            
+            address_result = generator(address_prompt, max_length=50, do_sample=False)
+            address = address_result[0]['generated_text'].strip()
+            
+            license_result = generator(license_prompt, max_length=50, do_sample=False)
+            license_number = license_result[0]['generated_text'].strip()
+            
+            dob_result = generator(dob_prompt, max_length=50, do_sample=False)
+            date_of_birth = dob_result[0]['generated_text'].strip()
+            
+            exp_result = generator(exp_prompt, max_length=50, do_sample=False)
+            expiration_date = exp_result[0]['generated_text'].strip()
+            
+            state_result = generator(state_prompt, max_length=10, do_sample=False)
+            state = state_result[0]['generated_text'].strip()
+            
+            # Clean up the AI responses
+            def clean_response(response, max_length=100):
+                if not response or response == "Not found":
+                    return "Not found"
+                # Take only the first part if it's too long
+                if len(response) > max_length:
+                    response = response[:max_length].split()[0] if response.split() else "Not found"
+                return response.strip()
+            
+            # Create the extracted data
+            extracted = {
+                "name": clean_response(name, 50),
+                "address": clean_response(address, 100),
+                "license_number": clean_response(license_number, 30),
+                "date_of_birth": clean_response(date_of_birth, 20),
+                "expiration_date": clean_response(expiration_date, 20),
+                "state": clean_response(state, 10)
+            }
+            
+        except Exception as e:
+            print(f"AI extraction failed: {e}")
+            extracted = {
+                "name": "AI extraction failed",
+                "address": "AI extraction failed", 
+                "license_number": "AI extraction failed",
+                "date_of_birth": "AI extraction failed",
+                "expiration_date": "AI extraction failed",
+                "state": "AI extraction failed",
+                "error": f"AI model error: {str(e)}"
+            }
+        
+        # Format JSON result
+        json_result = json.dumps(extracted, indent=2)
+        
+        return raw_text, cleaned_text, json_result
     
-    return str(output)
+    except Exception as e:
+        error_msg = f"Processing failed: {str(e)}"
+        return error_msg, error_msg, json.dumps({"error": error_msg}, indent=2)
 
 # Create Gradio interface
-with gr.Blocks(title="MCA Application Processor") as demo:
-    gr.Markdown("# 💼 MCA Application Processor")
-    gr.Markdown("Enter application details to get a risk assessment and decision. Decision is based on sentiment analysis, financial ratios (Revenue/Expenses > 1.2, Advance Coverage > 1.0), and a reasonable request rule (Advance <= 50% of net income and <= 80% of revenue).")
+with gr.Blocks(title="Driver's License Information Extractor") as demo:
+    gr.Markdown("# 🆔 Driver's License Information Extractor")
+    gr.Markdown("Upload a driver's license image to extract information using OCR and AI processing. The system will show raw OCR text, cleaned text, and structured JSON results.")
     
     with gr.Row():
         with gr.Column():
-            company = gr.Textbox(label="Company Name", value="Acme Corp")
-            monthly_revenue = gr.Number(label="Monthly Revenue ($)", value=120000, precision=0)
-            monthly_expenses = gr.Number(label="Monthly Expenses ($)", value=90000, precision=0)
-            requested_advance = gr.Number(label="Requested Advance ($)", value=50000, precision=0)
-            additional_text = gr.Textbox(label="Additional Context (Optional)", placeholder="e.g., 'Business has steady growth'", lines=2)
-            
-            submit_btn = gr.Button("Process Application", variant="primary")
+            image_input = gr.Image(
+                label="Upload Driver's License Image", 
+                type="pil",
+                height=400
+            )
+            submit_btn = gr.Button("Extract Information", variant="primary")
         
         with gr.Column():
-            output = gr.Textbox(label="Result", lines=10, interactive=False)
+            raw_ocr = gr.Textbox(
+                label="Raw OCR Text", 
+                lines=8, 
+                interactive=False,
+                placeholder="Raw text extracted by Tesseract OCR will appear here..."
+            )
+            cleaned_text = gr.Textbox(
+                label="Cleaned OCR Text", 
+                lines=8, 
+                interactive=False,
+                placeholder="Cleaned and normalized text will appear here..."
+            )
+            json_result = gr.JSON(
+                label="Extracted Information (JSON)",
+                interactive=False
+            )
     
     submit_btn.click(
-        fn=process_application,
-        inputs=[company, monthly_revenue, monthly_expenses, requested_advance, additional_text],
-        outputs=output
+        fn=extract_dl_info,
+        inputs=[image_input],
+        outputs=[raw_ocr, cleaned_text, json_result]
     )
 
 if __name__ == "__main__":