Upload 7 files

.env.example

@@ -0,0 +1,10 @@
+# Cloudinary
+CLOUDINARY_CLOUD_NAME=your_cloud_name
+CLOUDINARY_API_KEY=your_api_key
+CLOUDINARY_API_SECRET=your_api_secret
+
+# NVIDIA API
+NVIDIA_API_KEY=your_nvidia_api_key
+
+# MongoDB
+MONGODB_URI=mongodb+srv://username:password@cluster0.sxci1.mongodb.net/?retryWrites=true&w=majority

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+testimage.jpeg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.10-slim
+
+# Install system dependencies including Tesseract OCR
+RUN apt-get update && apt-get install -y \
+    tesseract-ocr \
+    libtesseract-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Set environment variables for Gradio
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT="7860"
+
+# Expose the Gradio port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -10,4 +10,121 @@ app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ⚖️ Automated Legal Document Digitization System
+
+Upload a photo of a legal document (bailable warrant, summon, etc.) and get back structured JSON data — automatically.
+
+## Pipeline
+
+```
+Image Upload → Cloudinary Hosting → Tesseract OCR → NVIDIA Qwen 2.5 LLM → Structured JSON
+```
+
+---
+
+## Prerequisites
+
+### 1. Install Tesseract OCR (System Binary)
+
+Python's `pytesseract` is only a wrapper — you need the **Tesseract engine** installed on your OS.
+
+#### Windows
+1. Download the installer from: https://github.com/UB-Mannheim/tesseract/wiki
+2. Run the installer (default path: `C:\Program Files\Tesseract-OCR\`)
+3. **Add to PATH** or uncomment the line in `app.py`:
+   ```python
+   pytesseract.pytesseract.tesseract_cmd = r"C:\Program Files\Tesseract-OCR\tesseract.exe"
+   ```
+
+#### Linux (Debian / Ubuntu)
+```bash
+sudo apt-get update
+sudo apt-get install tesseract-ocr
+```
+
+#### macOS
+```bash
+brew install tesseract
+```
+
+### 2. Verify Tesseract
+```bash
+tesseract --version
+```
+
+---
+
+## Setup
+
+### 1. Clone & Install Dependencies
+
+```bash
+cd police
+pip install -r requirements.txt
+```
+
+### 2. Create a `.env` File
+
+Create a `.env` file in the project root with your credentials:
+
+```env
+# Cloudinary
+CLOUDINARY_CLOUD_NAME=your_cloud_name
+CLOUDINARY_API_KEY=your_api_key
+CLOUDINARY_API_SECRET=your_api_secret
+
+# NVIDIA API
+NVIDIA_API_KEY=your_nvidia_api_key
+```
+
+| Variable | Where to get it |
+|---|---|
+| `CLOUDINARY_*` | [Cloudinary Console](https://console.cloudinary.com/) → Dashboard |
+| `NVIDIA_API_KEY` | [NVIDIA Build](https://build.nvidia.com/) → API Catalog → Get API Key |
+
+### 3. Run the App
+
+```bash
+python app.py
+```
+
+The Gradio interface will launch at **http://127.0.0.1:7860**.
+
+---
+
+## Output Fields
+
+The LLM extracts these fields into a JSON object:
+
+| Key | Description |
+|---|---|
+| `Case_FIR_Number` | FIR or case reference number |
+| `Act_and_Sections` | Applicable legal acts and sections |
+| `Type_of_Document` | Warrant, summon, notice, etc. |
+| `Target_Police_Station` | Police station the document is addressed to |
+| `IO_Name_and_Belt_No` | Investigating Officer's name and belt number |
+| `IO_Mobile_Number` | IO's contact number |
+| `Person_Name_To_Serve` | Name of the person to be served |
+| `Person_Address` | Address of the person |
+| `Court_Name` | Issuing court name |
+| `Hearing_Date` | Scheduled hearing / appearance date |
+
+---
+
+## Project Structure
+
+```
+police/
+├── app.py              # Main application (single file)
+├── requirements.txt    # Python dependencies
+├── .env                # API keys (DO NOT commit)
+└── README.md           # This file
+```
+
+---
+
+## Notes
+
+- OCR accuracy depends on image quality. Clear, well-lit photos produce the best results.
+- The LLM sets fields to `null` when they can't be extracted from the OCR text.
+- All uploaded images are stored in the `warrants/` folder on your Cloudinary account.

app.py

@@ -0,0 +1,371 @@
+"""
+Automated Legal Document Digitization System
+=============================================
+Accepts an image of a legal document (warrant, summon, etc.),
+hosts it on Cloudinary, extracts text via Tesseract OCR,
+and parses structured data using NVIDIA's Qwen3-Coder-480B-A35B-Instruct.
+"""
+
+import os
+import re
+import json
+import traceback
+
+import gradio as gr
+import cloudinary
+import cloudinary.uploader
+import pytesseract
+from PIL import Image
+from openai import OpenAI
+from dotenv import load_dotenv
+
+# ──────────────────────────────────────────────
+# A.  Setup & Configuration
+# ──────────────────────────────────────────────
+
+load_dotenv()
+
+# Cloudinary
+cloudinary.config(
+    cloud_name=os.environ.get("CLOUDINARY_CLOUD_NAME"),
+    api_key=os.environ.get("CLOUDINARY_API_KEY"),
+    api_secret=os.environ.get("CLOUDINARY_API_SECRET"),
+)
+
+# NVIDIA API via OpenAI SDK
+client = OpenAI(
+    base_url="https://integrate.api.nvidia.com/v1",
+    api_key=os.environ.get("NVIDIA_API_KEY"),
+)
+
+# Optional: point to Tesseract binary on Windows
+# In Docker/Linux, tesseract is in the system PATH.
+if os.name == 'nt':
+    tesseract_windows_path = r"C:\Program Files\Tesseract-OCR\tesseract.exe"
+    if os.path.exists(tesseract_windows_path):
+        pytesseract.pytesseract.tesseract_cmd = tesseract_windows_path
+
+from pymongo import MongoClient
+from datetime import datetime
+
+# MongoDB Connection
+mongo_uri = os.environ.get("MONGODB_URI")
+mongo_client = None
+db = None
+collection = None
+
+if mongo_uri:
+    try:
+        mongo_client = MongoClient(mongo_uri, serverSelectionTimeoutMS=5000)
+        # Ping the server to verify connection immediately
+        mongo_client.admin.command('ping')
+        db = mongo_client["police_db"]
+        collection = db["warrants"]
+        print("Connected successfully to MongoDB!")
+    except Exception as exc:
+        print(f"MongoDB connection failed: {exc}")
+        collection = None
+
+# ──────────────────────────────────────────────
+# B.  Core Processing Logic
+# ──────────────────────────────────────────────
+
+SYSTEM_PROMPT = (
+    "You are an expert legal document parser. "
+    "I will provide raw, messy OCR text from a bailable warrant. "
+    "Extract the following fields and return ONLY a valid JSON object. "
+    "No markdown, no explanations.\n\n"
+    "Required keys:\n"
+    "  Case_FIR_Number\n"
+    "  Act_and_Sections\n"
+    "  Type_of_Document\n"
+    "  Target_Police_Station\n"
+    "  IO_Name_and_Belt_No\n"
+    "  IO_Mobile_Number\n"
+    "  Person_Name_To_Serve\n"
+    "  Person_Address\n"
+    "  Court_Name\n"
+    "  Hearing_Date\n\n"
+    "If a field cannot be found, set its value to null."
+)
+
+
+def process_document(image_path: str):
+    """
+    End-to-end pipeline:
+      1. Upload image to Cloudinary
+      2. Run Tesseract OCR
+      3. Send raw text to NVIDIA Qwen for structured parsing
+      4. Return (cloudinary_url, raw_ocr_text, parsed_json)
+    """
+
+    if image_path is None:
+        raise gr.Error("Please upload an image first.")
+
+    # ── Step 1: Cloudinary Upload ──────────────────────────
+    try:
+        upload_result = cloudinary.uploader.upload(
+            image_path,
+            folder="warrants",
+            resource_type="image",
+        )
+        cloudinary_url = upload_result.get("secure_url", "")
+    except Exception as exc:
+        raise gr.Error(f"Cloudinary upload failed: {exc}")
+
+    # ── Step 2: OCR via Tesseract ──────────────────────────
+    try:
+        img = Image.open(image_path)
+        raw_text = pytesseract.image_to_string(img, lang="eng")
+    except Exception as exc:
+        raw_text = f"[OCR Error] {exc}"
+
+    if not raw_text.strip():
+        raw_text = "[OCR returned empty text — image may be blank or unreadable]"
+
+    # ── Step 3 & 4: LLM Prompt + API Call ──────────────────
+    prompt = f"{SYSTEM_PROMPT}\n\n--- RAW OCR TEXT ---\n{raw_text}\n--- END ---"
+
+    llm_response = None
+    last_exception = None
+    models_to_try = [
+        "qwen/qwen3-coder-480b-a35b-instruct",
+        "meta/llama-3.3-70b-instruct",
+        "nvidia/llama-3.1-nemotron-70b-instruct",
+        "qwen/qwen3.5-122b-a10b",
+    ]
+
+    for model_name in models_to_try:
+        try:
+            print(f"Attempting API call with model: {model_name}...")
+            completion = client.chat.completions.create(
+                model=model_name,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.7,
+                top_p=0.8,
+                max_tokens=4096,
+                stream=True,
+            )
+            chunks = []
+            print(f"\n--- LLM Response Streaming ({model_name}) ---")
+            for chunk in completion:
+                if chunk.choices and chunk.choices[0].delta.content is not None:
+                    content = chunk.choices[0].delta.content
+                    print(content, end="", flush=True)
+                    chunks.append(content)
+            print("\n--- End of Streaming ---\n")
+            llm_response = "".join(chunks)
+            break
+        except Exception as exc:
+            print(f"Model {model_name} failed: {exc}")
+            last_exception = exc
+            continue
+
+    if llm_response is None:
+        raise gr.Error(f"NVIDIA API call failed on all models. Last error: {last_exception}")
+
+    parsed_json = _clean_and_parse_json(llm_response)
+
+    # ── Step 6: Store in MongoDB ───────────────────────────
+    if collection is not None and "_parse_error" not in parsed_json:
+        try:
+            record = {
+                **parsed_json,
+                "cloudinary_url": cloudinary_url,
+                "raw_ocr_text": raw_text,
+                "uploaded_at": datetime.utcnow(),
+            }
+            collection.insert_one(record)
+            print("Record stored successfully in MongoDB!")
+        except Exception as exc:
+            print(f"Failed to store in MongoDB: {exc}")
+
+    return cloudinary_url, raw_text, parsed_json
+
+
+REQUIRED_KEYS = [
+    "Case_FIR_Number",
+    "Act_and_Sections",
+    "Type_of_Document",
+    "Target_Police_Station",
+    "IO_Name_and_Belt_No",
+    "IO_Mobile_Number",
+    "Person_Name_To_Serve",
+    "Person_Address",
+    "Court_Name",
+    "Hearing_Date"
+]
+
+
+def _clean_and_parse_json(raw_response: str) -> dict:
+    """
+    Strip markdown code fences (```json ... ```) and parse JSON.
+    Normalizes keys to match REQUIRED_KEYS, handling casing and spacing.
+    Falls back to a descriptive error dict on failure.
+    """
+    cleaned = raw_response.strip()
+
+    # Remove ```json ... ``` or ``` ... ```
+    cleaned = re.sub(r"^```(?:json)?\s*", "", cleaned)
+    cleaned = re.sub(r"\s*```$", "", cleaned)
+    cleaned = cleaned.strip()
+
+    try:
+        data = json.loads(cleaned)
+        if isinstance(data, dict):
+            # Normalize key typos (e.g. double underscores, trailing spaces)
+            normalized = {}
+            for k, v in data.items():
+                norm_k = k.replace("__", "_").strip()
+                normalized[norm_k] = v
+            
+            # Reconstruct dict ensuring 100% exact required keys are returned
+            final_data = {}
+            for req in REQUIRED_KEYS:
+                match_val = None
+                found = False
+                for k, v in normalized.items():
+                    if k.lower() == req.lower():
+                        match_val = v
+                        found = True
+                        break
+                final_data[req] = match_val if found else None
+            return final_data
+        return data
+    except json.JSONDecodeError:
+        return {
+            "_parse_error": True,
+            "_raw_llm_response": raw_response,
+            "_message": "Could not parse LLM response as JSON. See raw response above.",
+        }
+
+
+def fetch_live_warrants(search_query: str = ""):
+    """
+    Fetch all warrants from MongoDB, filter by search_query if provided,
+    and return a list of lists representing the table rows.
+    """
+    if search_query is None or not isinstance(search_query, str):
+        search_query = ""
+        
+    if collection is None:
+        return [["Database connection not available", "", "", "", "", "", "", "", "", "", ""]]
+    
+    query = {}
+    if search_query.strip():
+        # Search across major fields case-insensitively
+        rgx = {"$regex": search_query.strip(), "$options": "i"}
+        query = {
+            "$or": [
+                {"Case_FIR_Number": rgx},
+                {"Type_of_Document": rgx},
+                {"Target_Police_Station": rgx},
+                {"IO_Name_and_Belt_No": rgx},
+                {"Person_Name_To_Serve": rgx},
+                {"Court_Name": rgx},
+            ]
+        }
+    
+    try:
+        cursor = collection.find(query).sort("uploaded_at", -1)
+        rows = []
+        for item in cursor:
+            uploaded_str = ""
+            if "uploaded_at" in item:
+                dt = item["uploaded_at"]
+                uploaded_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+            
+            rows.append([
+                uploaded_str,
+                item.get("Case_FIR_Number") or "",
+                item.get("Type_of_Document") or "",
+                item.get("Target_Police_Station") or "",
+                item.get("IO_Name_and_Belt_No") or "",
+                item.get("IO_Mobile_Number") or "",
+                item.get("Person_Name_To_Serve") or "",
+                item.get("Person_Address") or "",
+                item.get("Court_Name") or "",
+                item.get("Hearing_Date") or "",
+                item.get("cloudinary_url") or "",
+            ])
+        
+        if not rows:
+            return [["No records found matching search", "", "", "", "", "", "", "", "", "", ""]]
+        
+        return rows
+    except Exception as exc:
+        return [[f"Error fetching data: {exc}", "", "", "", "", "", "", "", "", "", ""]]
+
+
+# ──────────────────────────────────────────────
+# C.  Gradio Interface
+# ──────────────────────────────────────────────
+
+DESCRIPTION = """
+Upload a photo of a **bailable warrant**, **summon**, or similar legal document.  
+The system will:
+1. **Host** the image on Cloudinary  
+2. **Extract** raw text via Tesseract OCR  
+3. **Parse** structured data using NVIDIA Qwen 3 Coder 480B
+4. **Store** the output securely in MongoDB for live police tracking
+"""
+
+with gr.Blocks(title="⚖️ Automated Legal Document Digitization") as demo:
+    gr.Markdown("# ⚖️ Automated Legal Document Digitization System")
+    
+    with gr.Tabs():
+        with gr.Tab("📥 Digitization Pipeline"):
+            gr.Markdown(DESCRIPTION)
+            with gr.Row():
+                with gr.Column(scale=1):
+                    image_input = gr.Image(type="filepath", label="Upload Warrant / Summon Photo")
+                    submit_btn = gr.Button("🚀 Process Document", variant="primary")
+                with gr.Column(scale=2):
+                    cloudinary_url_out = gr.Textbox(label="☁️ Cloudinary URL")
+                    raw_ocr_out = gr.Textbox(label="🔍 Raw OCR Text (Debugging)", lines=8)
+                    json_out = gr.JSON(label="📋 Extracted Structured Data (JSON)")
+            
+            # Action wiring for process_document
+            submit_btn.click(
+                fn=process_document,
+                inputs=[image_input],
+                outputs=[cloudinary_url_out, raw_ocr_out, json_out]
+            )
+            
+        with gr.Tab("👮 Live Police Dashboard") as dashboard_tab:
+            gr.Markdown("## 📋 Real-Time Stored Warrants & Summons")
+            gr.Markdown("View and search all digitized legal documents stored securely in MongoDB.")
+            
+            with gr.Row():
+                search_box = gr.Textbox(placeholder="🔍 Search by Case Number, IO Name, Person, or Station...", show_label=False, scale=4)
+                refresh_btn = gr.Button("🔄 Refresh Database", variant="secondary", scale=1)
+                
+            headers = [
+                "Uploaded At",
+                "Case/FIR Number",
+                "Type of Document",
+                "Target Station",
+                "IO Name & Belt No",
+                "IO Mobile",
+                "Person to Serve",
+                "Address",
+                "Court Name",
+                "Hearing Date",
+                "Cloudinary Link"
+            ]
+            
+            db_df = gr.Dataframe(
+                value=fetch_live_warrants(""),
+                headers=headers,
+                datatype=["str"] * len(headers),
+                column_count=(len(headers), "fixed"),
+                interactive=False,
+                wrap=True,
+            )
+            
+            # Wire up search and refresh
+            search_box.change(fn=fetch_live_warrants, inputs=[search_box], outputs=[db_df])
+            refresh_btn.click(fn=fetch_live_warrants, inputs=[search_box], outputs=[db_df])
+            
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

model.md

@@ -0,0 +1,106 @@
+Qwen3-Coder-480B-A35B-Instruct
+Model Overview
+Description:
+Qwen3-Coder-480B-A35B-Instruct is a state-of-the-art large language model specifically designed for code generation and agentic coding tasks. It is a mixture-of-experts (MoE) model with 480B total parameters and 35B activated parameters, featuring native support for 262,144 tokens context length and extendable up to 1M tokens using YaRN.
+
+This model demonstrates significant performance among open models on Agentic Coding, Agentic Browser-Use, and other foundational coding tasks, achieving results comparable to Claude Sonnet. It supports function calling and tool choice capabilities, making it ideal for complex coding workflows and agentic applications.
+
+This model is ready for commercial use.
+
+License/Terms of Use
+GOVERNING TERMS: This trial service is governed by the NVIDIA API Trial Terms of Service. Use of this model is governed by the NVIDIA Community Model License. Additional Information: Apache 2.0.
+
+Deployment Geography
+Deployment Geography: Global
+
+Use Cases
+Code Generation: Generate high-quality code from natural language descriptions
+Agentic Coding: Execute complex coding workflows with function calling
+Repository Understanding: Process large codebases with long-context capabilities
+Tool Integration: Interface with development tools and APIs
+Code Review and Analysis: Analyze and improve existing code
+Documentation Generation: Create code documentation and comments
+Browser Automation: Agentic browser-use scenarios
+Function Calling: Structured tool execution and API integration
+Release Information
+Release Date: 08/22/2025
+Build.NVIDIA.com: Available via link
+
+Third-Party Community Consideration
+This model is not owned or developed by NVIDIA. This model has been developed by Qwen (Alibaba Cloud). This model has been developed and built to a third-party's requirements for this application and use case; see link to Qwen3-Coder-480B-A35B-Instruct.
+
+References
+Qwen3-Coder: A Large Language Model for Code Generation
+Qwen3-Coder GitHub Repository
+Qwen Documentation
+Hugging Face Model Page
+Qwen3 Technical Report (arXiv:2505.09388)
+Model Architecture
+Architecture Type: mixture-of-experts (MoE) with Sparse Activation
+Network Architecture: Qwen3MoeForCausalLM (Transformer-based decoder-only)
+Parameter Count: 480B total parameters with 35B activated parameters
+Expert Configuration: 160 experts with 8 activated per forward pass
+Attention Mechanism: Grouped Query Attention (GQA) with 96 query heads and 8 KV heads
+Number of Layers: 62
+Hidden Size: 6144
+Head Dimension: 128
+Intermediate Size: 8192
+MoE Intermediate Size: 2560
+Context Length: 262,144 tokens (native), extendable to 1M with YaRN
+Vocabulary Size: 151,936
+
+Input
+Input Type(s): Text, Code, Function calls
+Input Format(s): Natural language prompts, code snippets, structured function calls
+Input Parameters:
+
+Max input length: 262,144 tokens (native), up to 1M with YaRN
+Support for function calling format
+Tool choice enabled
+Trust remote code execution
+Custom tool call parser (qwen3_coder)
+Output
+Output Type(s): Text, Code, Function responses
+Output Format(s): Natural language responses, code generation, structured function outputs
+Output Parameters: One-Dimensional (1D)
+
+Max output length: Configurable based on remaining context
+Function call responses in structured format
+Other Properties Related to Output:
+
+Non-thinking mode (no <think></think> blocks)
+Auto tool choice responses
+Software Integration
+Runtime Engine: vLLM, Transformers (4.51.0+)
+Supported Hardware Platform(s): NVIDIA Hopper
+Supported Operating System(s): Linux
+Data Type: FP8
+Data Modality: Text
+Model Version: v1.0
+
+Training, Testing, and Evaluation Datasets
+Training Dataset
+Data Collection Method by dataset: The model was trained on a diverse dataset including code repositories, documentation, and natural language text related to programming
+Labeling Method by dataset: Supervised fine-tuning with instruction-following data
+Properties: Multi-language code support, instruction-following capabilities, function calling training
+Testing Dataset
+Data Collection Method by dataset: Standard benchmarks for code generation and agentic tasks
+Labeling Method by dataset: Automated evaluation metrics
+Properties: HumanEval, MBPP, Agentic coding benchmarks
+Evaluation Dataset
+Data Collection Method by dataset: Public benchmarks and custom evaluation sets
+Labeling Method by dataset: Automated metrics and human evaluation
+Properties: Code generation quality, function calling accuracy, agentic task performance
+Benchmark Results
+The model achieves significant performance among open models on:
+
+Agentic Coding tasks
+Agentic Browser-Use scenarios
+Foundational coding benchmarks
+Results comparable to Claude Sonnet on various coding tasks
+Inference
+Acceleration Engine: vLLM
+Test Hardware: NVIDIA Hopper
+
+Ethical Considerations
+NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.

requirements.txt

@@ -0,0 +1,8 @@
+gradio==4.44.1
+cloudinary
+pytesseract
+pillow
+openai
+python-dotenv
+pymongo
+dnspython