Upload 4 files

README.md

@@ -1,39 +1,19 @@
 ---
-title: DeepSeek-OCR Full-Page CSV
+title: DeepSeek OCR + Telegram
 emoji: 📄
 colorFrom: blue
-colorTo: green
+colorTo: indigo
 sdk: gradio
 sdk_version: 5.49.1
-python_version: "3.10"
+python_version: 3.10.13
 app_file: app.py
 pinned: false
 ---
 
-# DeepSeek-OCR full-page CSV Space
+# DeepSeek-OCR Gradio Space with optional Telegram bot
 
-This Space runs `strangervisionhf/deepseek-ocr-transformers-v4.57.6`, provides full-page OCR, CSV preview/download, and an optional Telegram polling bot.
+This Space uses the `strangervisionhf/deepseek-ocr-transformers-v4.57.6` model.
 
-## Configuration
+To enable Telegram, add a Space secret named `TELEGRAM_BOT_TOKEN` with the token from BotFather. Long polling is used; `WEBHOOK_URL` is not required. For privacy, optionally set `TELEGRAM_ALLOWED_USER_IDS` to a comma-separated list of trusted Telegram numeric user IDs.
 
-In **Settings → Variables and secrets**, set:
-
-- Secret `TELEGRAM_BOT_TOKEN`: your Telegram bot token. Do not put it in source files. If a token has been exposed, revoke it with BotFather and replace this secret.
-- Variable `OCR_PROFILE`: `gundam`, `small`, or `tiny`.
-- Variable `GPU_DURATION_SECONDS`: requested GPU reservation duration. The platform's allowed duration/quota still applies.
-
-## Install these files
-
-Keep `README.md`, `requirements.txt`, and `app.py` in the **root** of the Space repository. Commit them together, then use **Factory Rebuild** so the SDK version in this README is applied.
-
-The Gradio version is selected here by `sdk_version`. Do not add a separate `gradio` line to `requirements.txt`.
-
-## CSV fields
-
-`voter_id`, `name`, `relative_type`, `relative_name`, `house_number`, `age`, `gender`, `photo_status`
-
-OCR and grouping may be imperfect. Review the output CSV against the source image before relying on it.
-
-## Telegram
-
-Only one active polling process can use a bot token at a time. If logs show `Conflict: terminated by other getUpdates request`, stop other processes or Spaces using the same token.
+The app's CSV/database extraction targets voter-style rows only. Review OCR results before saving them and avoid uploading identity documents unless you are authorized to process them.

app.py

@@ -1,13 +1,7 @@
-"""DeepSeek-OCR full-page electoral-roll OCR with CSV export and Telegram bot.
+"""DeepSeek-OCR Gradio app with optional Telegram long-polling bot.
 
-Environment variables (set these in Hugging Face Space Settings):
-  TELEGRAM_BOT_TOKEN  Telegram bot token (secret; never put it in this file)
-  OCR_PROFILE         tiny | small | base | large | gundam (default: gundam)
-  GPU_DURATION_SECONDS  ZeroGPU reservation requested by @spaces.GPU (default: 180)
-
-The app runs one model.infer() call for each uploaded full page. The Gundam profile
-allows the model to create internal crops while still processing the uploaded page
-as one OCR job. OCR-to-record grouping is heuristic; check a sample of the CSV.
+Use a Gradio Space configured for Gradio 5.49.1 and ZeroGPU/GPU hardware.
+Set TELEGRAM_BOT_TOKEN in Space Settings -> Variables and secrets to enable Telegram.
 """
 
 from __future__ import annotations
@@ -15,889 +9,493 @@ from __future__ import annotations
 import asyncio
 import csv
 import html
-import io
+import json
 import logging
 import os
 import re
+import sqlite3
 import tempfile
 import threading
-import time
+import uuid
 from pathlib import Path
-from statistics import median
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+from typing import Any
 
-import gradio as gr
+# Import spaces before torch, as recommended for ZeroGPU Spaces.
+import spaces
 import torch
-from PIL import Image, ImageOps
+import gradio as gr
+from PIL import Image
 from transformers import AutoModel, AutoTokenizer
 
-try:
-    import spaces
-except ImportError:  # Useful for local parser/UI checks outside Hugging Face Spaces.
-    class _SpacesFallback:
-        @staticmethod
-        def GPU(*args, **kwargs):
-            def decorator(func):
-                return func
-            return decorator
-    spaces = _SpacesFallback()  # type: ignore[assignment]
-
-
-# -----------------------------------------------------------------------------
-# Configuration
-# -----------------------------------------------------------------------------
-
-MODEL_ID = "strangervisionhf/deepseek-ocr-transformers-v4.57.6"
-DEFAULT_PROFILE = os.getenv("OCR_PROFILE", "gundam").strip().lower()
-try:
-    GPU_DURATION_SECONDS = int(os.getenv("GPU_DURATION_SECONDS", "180"))
-except ValueError:
-    GPU_DURATION_SECONDS = 180
-GPU_DURATION_SECONDS = max(10, GPU_DURATION_SECONDS)
-
-# Telegram BotFather token must be set as a Hugging Face Space Secret.
-TELEGRAM_BOT_TOKEN = (
-    os.getenv("TELEGRAM_BOT_TOKEN", "").strip()
-    or os.getenv("BOT_TOKEN", "").strip()
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import (
+    Application,
+    CallbackQueryHandler,
+    CommandHandler,
+    ContextTypes,
+    MessageHandler,
+    filters,
 )
 
-OCR_PROFILES: Dict[str, Dict[str, Any]] = {
-    "tiny": {"base_size": 512, "image_size": 512, "crop_mode": False},
-    "small": {"base_size": 640, "image_size": 640, "crop_mode": False},
-    "base": {"base_size": 1024, "image_size": 1024, "crop_mode": False},
-    "large": {"base_size": 1280, "image_size": 1280, "crop_mode": False},
-    "gundam": {"base_size": 1024, "image_size": 640, "crop_mode": True},
-}
-if DEFAULT_PROFILE not in OCR_PROFILES:
-    DEFAULT_PROFILE = "gundam"
-
-CSV_COLUMNS = [
-    "voter_id",
-    "name",
-    "relative_type",
-    "relative_name",
-    "house_number",
-    "age",
-    "gender",
-    "photo_status",
-]
-
-# The standard DeepSeek-OCR document prompt, followed by explicit instructions
-# for the target document. The model may still emit grounded regions; the parser
-# below handles both HTML/Markdown tables and grounded region output.
-#OCR_PROMPT = 
-
-OCR_PROMPT = """<image>
-<|grounding|>
-Perform OCR on the actual image of this complete Indian electoral-roll page.
-
-Read the printed content in every voter card across the entire page.
-Preserve the original Hindi and English text. Keep each field associated
-with the voter card where it appears. Do not combine details from different cards.
-
-Return the recognized document content only. Do not repeat these instructions.
-Do not invent or guess unreadable values.
-
-For each voter card, extract these fields:
-voter_id, name, relative_type, relative_name, house_number, age, gender, photo_status
-
-Return one Markdown table row per voter card, using exactly these eight columns.
-Leave a field blank if it cannot be read.
-If no voter information can be recognized, return:
-OCR_FAILED: No voter information recognized.
-"""
 
 logging.basicConfig(
-    level=os.getenv("LOG_LEVEL", "INFO").upper(),
+    level=os.getenv("LOG_LEVEL", "INFO"),
     format="%(asctime)s %(levelname)s %(name)s: %(message)s",
 )
-logger = logging.getLogger("deepseek-ocr-csv")
-
-
-# -----------------------------------------------------------------------------
-# Load model once at startup
-# -----------------------------------------------------------------------------
-
-logger.info("Loading OCR model: %s", MODEL_ID)
-logger.info("Default OCR profile=%s; GPU reservation=%ss", DEFAULT_PROFILE, GPU_DURATION_SECONDS)
-DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-logger.info("OCR device: %s", DEVICE)
+logger = logging.getLogger("deepseek_ocr")
 
-TOKENIZER = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
-MODEL = AutoModel.from_pretrained(
-    MODEL_ID,
-    trust_remote_code=True,
-    use_safetensors=True,
+MODEL_ID = os.getenv(
+    "MODEL_ID", "strangervisionhf/deepseek-ocr-transformers-v4.57.6"
 )
-MODEL = MODEL.to(DEVICE).eval()
-if DEVICE.type == "cuda":
+GPU_DURATION_SECONDS = int(os.getenv("GPU_DURATION_SECONDS", "120"))
+TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "").strip()
+DB_PATH = os.getenv("DB_PATH", "ocr_records.db")
+MAX_TELEGRAM_FILE_BYTES = 20 * 1024 * 1024
+
+# Optional comma-separated allowlist of Telegram numeric user IDs.
+# Example: TELEGRAM_ALLOWED_USER_IDS=123456789,987654321
+_allowed_raw = os.getenv("TELEGRAM_ALLOWED_USER_IDS", "").strip()
+if _allowed_raw:
     try:
-        target_dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
-        MODEL = MODEL.to(dtype=target_dtype)
-        logger.info("Model dtype: %s", target_dtype)
-    except Exception:
-        logger.exception("Could not select reduced-precision CUDA dtype; continuing with model default")
-logger.info("OCR model loaded successfully")
-
-
-# -----------------------------------------------------------------------------
-# OCR and parser helpers
-# -----------------------------------------------------------------------------
-
-# Supports electoral-roll style IDs such as UP/53/264/726430 and EPIC-like IDs
-# such as ABC1234567. The patterns are intentionally anchored by boundaries.
-SLASH_ID_RE = re.compile(
-    r"(?<![A-Z0-9])([A-Z]{2,5}\s*/\s*\d{1,4}(?:\s*/\s*\d{1,8}){2,3})(?![A-Z0-9])",
-    re.IGNORECASE,
-)
-EPIC_ID_RE = re.compile(r"(?<![A-Z0-9])([A-Z]{3}\s*[- ]?\s*\d{6,8})(?![A-Z0-9])", re.IGNORECASE)
-
-HTML_TD_RE = re.compile(r"<td\b[^>]*>(.*?)</td\s*>", re.IGNORECASE | re.DOTALL)
-HTML_ROW_RE = re.compile(r"<tr\b[^>]*>(.*?)</tr\s*>", re.IGNORECASE | re.DOTALL)
-GROUNDED_BLOCK_RE = re.compile(
-    r"<\|ref\|>(?P<ref>.*?)<\|/ref\|>\s*"
-    r"<\|det\|>\s*\[\[(?P<coords>.*?)\]\]\s*<\|/det\|>\s*"
-    r"(?P<text>.*?)(?=<\|ref\|>|$)",
-    re.DOTALL,
-)
+        ALLOWED_TELEGRAM_USER_IDS: set[int] | None = {
+            int(item.strip()) for item in _allowed_raw.split(",") if item.strip()
+        }
+    except ValueError as exc:
+        raise RuntimeError(
+            "TELEGRAM_ALLOWED_USER_IDS must contain comma-separated numeric IDs."
+        ) from exc
+else:
+    ALLOWED_TELEGRAM_USER_IDS = None
+
+PROMPTS = {
+    "Convert to Markdown": "<image>\n<|grounding|>Convert the document to markdown.",
+    "Free OCR": "<image>\nFree OCR.",
+    "Parse Figure": "<image>\nParse the figure.",
+}
 
-# Order matters: longer relative-name labels appear before the generic "नाम".
-LABEL_RE = re.compile(
-    r"(?P<father>पिता\s*का\s*नाम|पिता\s*नाम|Father(?:'s)?\s+Name|Father)"
-    r"|(?P<husband>पति\s*का\s*नाम|पति\s*नाम|Husband(?:'s)?\s+Name|Husband)"
-    r"|(?P<mother>माता\s*का\s*नाम|माता\s*नाम|Mother(?:'s)?\s+Name|Mother)"
-    r"|(?P<other>अन्य\s*का\s*नाम|संबंधी\s*का\s*नाम|Other\s+Relative)"
-    r"|(?P<house>मकान\s*संख्या|मकान\s*नं\.?|घर\s*संख्या|House\s*(?:Number|No\.?)|House)"
-    r"|(?P<age>आयु|उम्र|Age)"
-    r"|(?P<gender>लिंग|Gender|Sex)"
-    r"|(?P<name>(?<!का\s)नाम|(?<![A-Za-z])Name(?![A-Za-z]))",
-    re.IGNORECASE,
+# Keep the existing voter-register field extraction, but support HTML tables,
+# Markdown tables, and plain OCR text. Verify every extracted field before saving.
+VOTER_ID_RE = re.compile(
+    r"(?<![A-Z0-9])(?:UP/\d+/\d+/\d+|[A-Z]{3}\d{7,})(?![A-Z0-9])",
+    flags=re.IGNORECASE,
 )
 
-PHOTO_AVAILABLE_RE = re.compile(r"फोटो\s*(?:उपलब्ध|मौजूद)\s*(?:है)?|photo\s+available", re.IGNORECASE)
-PHOTO_UNAVAILABLE_RE = re.compile(
-    r"फोटो\s*(?:उपलब्ध\s*नहीं|नहीं\s*है|अनुपलब्ध)|photo\s+(?:not\s+available|unavailable)",
-    re.IGNORECASE,
-)
 
+def _clean_markup(value: str) -> str:
+    value = html.unescape(value or "")
+    value = re.sub(r"<br\s*/?>", "\n", value, flags=re.IGNORECASE)
+    value = re.sub(r"</(?:td|th|tr|p|div|li|section)>\s*", "\n", value, flags=re.IGNORECASE)
+    value = re.sub(r"<[^>]+>", " ", value)
+    value = value.replace("\xa0", " ").replace("|", " ")
+    lines = [re.sub(r"[ \t\r]+", " ", line).strip() for line in value.splitlines()]
+    return "\n".join(line for line in lines if line)
 
-def empty_record() -> Dict[str, str]:
-    return {column: "" for column in CSV_COLUMNS}
-
-
-def _clean_text(value: Any) -> str:
-    """Turn model markup into readable text while preserving Hindi characters."""
-    text = html.unescape(str(value or ""))
-    text = re.sub(r"<\|ref\|>.*?<\|/ref\|>", " ", text, flags=re.DOTALL)
-    text = re.sub(r"<\|det\|>.*?<\|/det\|>", " ", text, flags=re.DOTALL)
-    text = re.sub(r"<\|[^|]+\|>", " ", text)
-    text = re.sub(r"</?\s*(?:table|tbody|thead|tfoot|tr|td|th|p|div|span|li|ul|ol|strong|b|em)\b[^>]*>", "\n", text, flags=re.IGNORECASE)
-    text = re.sub(r"<br\s*/?>", "\n", text, flags=re.IGNORECASE)
-    text = re.sub(r"!\[[^\]]*\]\([^)]*\)", " ", text)
-    text = re.sub(r"[`*_#]+", " ", text)
-    text = re.sub(r"[\t\r]+", " ", text)
-    text = re.sub(r"[ ]{2,}", " ", text)
-    text = re.sub(r"\n\s*\n\s*\n+", "\n\n", text)
-    return text.strip()
-
-
-def find_voter_ids(text: str) -> List[str]:
-    clean = html.unescape(text or "")
-    found: List[Tuple[int, str]] = []
-    for pattern in (SLASH_ID_RE, EPIC_ID_RE):
-        for match in pattern.finditer(clean):
-            raw_id = match.group(1).strip()
-            if "/" in raw_id:
-                normalized = re.sub(r"\s*/\s*", "/", raw_id).upper()
-            else:
-                normalized = re.sub(r"\s*[- ]\s*", "", raw_id).upper()
-            found.append((match.start(), normalized))
-    found.sort(key=lambda item: item[0])
-    result: List[str] = []
-    seen = set()
-    for _, voter_id in found:
-        if voter_id not in seen:
-            seen.add(voter_id)
-            result.append(voter_id)
-    return result
 
+def _extract_field(text: str, label: str) -> str:
+    labels = (
+        r"पिता\s*का\s*नाम|पति\s*का\s*नाम|मकान\s*संख्या|आयु|लिंग|(?<!का )नाम"
+    )
+    if label == "name":
+        start = r"(?<!का )नाम"
+    elif label == "father_name":
+        start = r"पिता\s*का\s*नाम"
+    elif label == "husband_name":
+        start = r"पति\s*का\s*नाम"
+    elif label == "house_no":
+        start = r"मकान\s*संख्या"
+    elif label == "age":
+        start = r"आयु"
+    elif label == "gender":
+        start = r"लिंग"
+    else:
+        return ""
 
-def _value_between(text: str, start: int, end: int) -> str:
-    value = text[start:end]
-    value = re.sub(r"^[\s:：=\-–—|,;]+", "", value)
-    value = re.sub(r"[\s:：=\-–—|,;]+$", "", value)
-    value = re.sub(r"\s+", " ", value).strip()
-    value = re.sub(r"(?:फोटो\s*(?:उपलब्ध|मौजूद)\s*(?:है)?|photo\s+available)", "", value, flags=re.IGNORECASE).strip()
+    match = re.search(
+        rf"{start}\s*[:：]?\s*(.*?)(?=\s*(?:{labels})\s*[:：]?|$)",
+        text,
+        flags=re.DOTALL,
+    )
+    if not match:
+        return ""
+    value = re.sub(r"\s+", " ", match.group(1)).strip(" \t\r\n:：-*|")
     return value
 
 
-def parse_fields(text: str) -> Dict[str, str]:
-    """Extract the known fields from one voter-card text region."""
-    text = _clean_text(text)
-    rec = empty_record()
-
-    ids = find_voter_ids(text)
-    if ids:
-        rec["voter_id"] = ids[0]
-
-    if PHOTO_UNAVAILABLE_RE.search(text):
-        rec["photo_status"] = "फोटो उपलब्ध नहीं है"
-    elif PHOTO_AVAILABLE_RE.search(text):
-        rec["photo_status"] = "फोटो उपलब्ध है"
-
-    matches = list(LABEL_RE.finditer(text))
-    for index, match in enumerate(matches):
-        next_start = matches[index + 1].start() if index + 1 < len(matches) else len(text)
-        value = _value_between(text, match.end(), next_start)
-        if not value:
-            continue
-
-        if match.lastgroup == "father":
-            rec["relative_type"] = "पिता"
-            if not rec["relative_name"]:
-                rec["relative_name"] = value
-        elif match.lastgroup == "husband":
-            rec["relative_type"] = "पति"
-            if not rec["relative_name"]:
-                rec["relative_name"] = value
-        elif match.lastgroup == "mother":
-            rec["relative_type"] = "माता"
-            if not rec["relative_name"]:
-                rec["relative_name"] = value
-        elif match.lastgroup == "other":
-            rec["relative_type"] = "अन्य"
-            if not rec["relative_name"]:
-                rec["relative_name"] = value
-        elif match.lastgroup == "house":
-            if not rec["house_number"]:
-                rec["house_number"] = value
-        elif match.lastgroup == "age":
-            age_match = re.search(r"\d{1,3}", value)
-            if age_match and not rec["age"]:
-                rec["age"] = age_match.group(0)
-        elif match.lastgroup == "gender":
-            gender_match = re.search(r"पुरुष|स्त्री|महिला|महिल|पुरूष|male|female|other|अन्य", value, re.IGNORECASE)
-            if gender_match and not rec["gender"]:
-                rec["gender"] = gender_match.group(0)
-        elif match.lastgroup == "name":
-            if not rec["name"]:
-                rec["name"] = value
-
-    # If field labels appear inline and were not recognized due to OCR punctuation,
-    # recover the common Hindi forms with simpler targeted expressions.
-    if not rec["name"]:
-        name_match = re.search(r"(?:^|\n)\s*नाम\s*[:：]?\s*([^\n]+)", text)
-        if name_match:
-            candidate = re.split(r"पिता\s*का\s*नाम|पति\s*का\s*नाम|मकान\s*संख्या|आयु|लिंग", name_match.group(1))[0]
-            rec["name"] = candidate.strip(" :：-")
-    if not rec["relative_name"]:
-        relative_match = re.search(
-            r"(पिता\s*का\s*नाम|पति\s*का\s*नाम|माता\s*का\s*नाम)\s*[:：]?\s*([^\n]+)", text
-        )
-        if relative_match:
-            rec["relative_type"] = "पिता" if relative_match.group(1).startswith("पिता") else ("पति" if relative_match.group(1).startswith("पति") else "माता")
-            rec["relative_name"] = re.split(r"मकान\s*संख्या|आयु|लिंग", relative_match.group(2))[0].strip(" :：-")
-    if not rec["house_number"]:
-        house_match = re.search(r"(?:मकान\s*संख्या|मकान\s*नं\.?|घर\s*संख्या)\s*[:：]?\s*([^\n]+)", text)
-        if house_match:
-            rec["house_number"] = re.split(r"आयु|उम्र|लिंग", house_match.group(1))[0].strip(" :：-")
-    if not rec["age"]:
-        age_match = re.search(r"(?:आयु|उम्र|Age)\s*[:：]?\s*(\d{1,3})", text, re.IGNORECASE)
-        if age_match:
-            rec["age"] = age_match.group(1)
-    if not rec["gender"]:
-        gender_match = re.search(r"(?:लिंग|Gender|Sex)\s*[:：]?\s*(पुरुष|स्त्री|महिला|पुरूष|male|female)", text, re.IGNORECASE)
-        if gender_match:
-            rec["gender"] = gender_match.group(1)
-
-    # Remove any leftover OCR artifacts from each value; don't translate/correct the content.
-    for col in CSV_COLUMNS:
-        rec[col] = re.sub(r"\s+", " ", rec[col]).strip(" :：|,;\t\n")
-    return rec
-
-
-def record_has_fields(record: Dict[str, str]) -> bool:
-    return any(record.get(key, "") for key in CSV_COLUMNS if key != "voter_id")
-
-
-def record_has_person_details(record: Dict[str, str]) -> bool:
-    """Whether this region contains card details rather than only a photo label."""
-    return any(record.get(key, "") for key in (
-        "name", "relative_type", "relative_name", "house_number", "age", "gender"
-    ))
-
-
-def merge_record(target: Dict[str, str], source: Dict[str, str]) -> None:
-    """Fill empty target fields. Existing non-empty values are not overwritten."""
-    for column in CSV_COLUMNS:
-        value = (source.get(column) or "").strip()
-        if value and not target.get(column):
-            target[column] = value
-
-
-def _records_from_html(raw: str) -> List[Dict[str, str]]:
-    """Parse HTML cells emitted by the model; pair IDs/details by document order."""
-    raw = html.unescape(raw or "")
-    raw_cells = HTML_TD_RE.findall(raw)
-    if not raw_cells:
+def _record_from_text(row_text: str, voter_id: str) -> dict[str, Any] | None:
+    cleaned = _clean_markup(row_text)
+    if "नाम" not in cleaned:
+        return None
+    age_text = _extract_field(cleaned, "age")
+    age_match = re.search(r"\d{1,3}", age_text)
+    return {
+        "voter_id": voter_id.strip(),
+        "name": _extract_field(cleaned, "name"),
+        "father_name": _extract_field(cleaned, "father_name"),
+        "husband_name": _extract_field(cleaned, "husband_name"),
+        "house_no": _extract_field(cleaned, "house_no"),
+        "age": int(age_match.group()) if age_match else 0,
+        "gender": _extract_field(cleaned, "gender"),
+    }
+
+
+def parse_markdown(raw: str) -> list[dict[str, Any]]:
+    """Extract rows from OCR output when it contains voter-like IDs and labels."""
+    if not raw:
         return []
 
-    cells = [_clean_text(cell) for cell in raw_cells]
-    cells = [cell for cell in cells if cell]
-    if not cells:
-        return []
+    candidate_rows: list[str] = []
 
-    # Preserve the flattened cell order. Some model outputs omit </table>, and some
-    # put multiple voter cards into a single visual <tr>, so row-level grouping alone
-    # is not safe for all layouts.
-    id_entries: List[Tuple[str, Dict[str, str], int]] = []
-    detail_entries: List[Tuple[Dict[str, str], int]] = []
-    photo_entries: List[Tuple[str, int]] = []
-
-    for cell_index, cell in enumerate(cells):
-        ids = find_voter_ids(cell)
-        parsed = parse_fields(cell)
-        if ids:
+    # HTML tables are common in DeepSeek-OCR's Markdown/table output.
+    html_rows = re.findall(r"<tr\b[^>]*>(.*?)</tr>", raw, flags=re.IGNORECASE | re.DOTALL)
+    if html_rows:
+        for row in html_rows:
+            cells = re.findall(r"<t[dh]\b[^>]*>(.*?)</t[dh]>", row, flags=re.IGNORECASE | re.DOTALL)
+            candidate_rows.append("\n".join(cells) if cells else row)
+    else:
+        # Markdown tables: inspect each pipe-delimited row while skipping separators.
+        for line in raw.splitlines():
+            if "|" not in line:
+                continue
+            cells = [cell.strip() for cell in line.strip().strip("|").split("|")]
+            if not cells or all(re.fullmatch(r":?-{3,}:?", c.replace(" ", "")) for c in cells if c):
+                continue
+            candidate_rows.append("\n".join(cells))
+
+    # Fallback for OCR text that is not formatted as a table: split around IDs.
+    if not candidate_rows:
+        clean = _clean_markup(raw)
+        found = list(VOTER_ID_RE.finditer(clean))
+        for index, match in enumerate(found):
+            end = found[index + 1].start() if index + 1 < len(found) else len(clean)
+            candidate_rows.append(f"{match.group()}\n{clean[match.start():end]}")
+
+    output: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    id_only: list[str] = []
+    details_only: list[str] = []
+
+    for row in candidate_rows:
+        cleaned_row = _clean_markup(row)
+        ids = list(dict.fromkeys(m.group().strip() for m in VOTER_ID_RE.finditer(cleaned_row)))
+        if ids and "नाम" in cleaned_row:
             for voter_id in ids:
-                id_entries.append((voter_id, parsed, cell_index))
-        elif record_has_person_details(parsed):
-            detail_entries.append((parsed, cell_index))
-        elif parsed.get("photo_status"):
-            photo_entries.append((parsed["photo_status"], cell_index))
-
-    if not id_entries:
-        return []
-
-    records: List[Dict[str, str]] = []
-    for voter_id, parsed, _ in id_entries:
-        rec = empty_record()
-        rec["voter_id"] = voter_id
-        merge_record(rec, parsed)
-        records.append(rec)
-
-    # In most source pages each ID cell has a corresponding details cell. Flattening
-    # both lists and pairing by index also handles several cards per visual row.
-    details_only = [entry[0] for entry in detail_entries]
-    if details_only:
-        for index, details in enumerate(details_only):
-            # If one cell already contains a complete record, don't shift later details.
-            target_index = index
-            if target_index < len(records):
-                merge_record(records[target_index], details)
-
-    # Photo status is often in a separate cell. Attach statuses in cell reading order
-    # when there is one status cell per record; otherwise attach conservatively by index.
-    if photo_entries:
-        for index, (status, _) in enumerate(photo_entries):
-            if index < len(records) and not records[index].get("photo_status"):
-                records[index]["photo_status"] = status
-
-    return _deduplicate_records(records)
-
-
-def _parse_grounded_blocks(raw: str) -> List[Dict[str, Any]]:
-    raw = html.unescape(raw or "")
-    blocks: List[Dict[str, Any]] = []
-    for match in GROUNDED_BLOCK_RE.finditer(raw):
-        coordinates = [int(round(float(number))) for number in re.findall(r"-?\d+(?:\.\d+)?", match.group("coords"))]
-        if len(coordinates) < 4:
-            continue
-        x1, y1, x2, y2 = coordinates[:4]
-        text = _clean_text(match.group("text"))
-        if not text:
-            continue
-        blocks.append({
-            "text": text,
-            "bbox": (x1, y1, x2, y2),
-            "cx": (x1 + x2) / 2.0,
-            "cy": (y1 + y2) / 2.0,
-            "record": parse_fields(text),
-        })
-    return blocks
-
-
-def _median_step(values: Sequence[float], fallback: float = 1000.0) -> float:
-    unique = sorted({round(value, 1) for value in values})
-    differences = [unique[i + 1] - unique[i] for i in range(len(unique) - 1)]
-    differences = [difference for difference in differences if difference > 20]
-    if differences:
-        return float(median(differences))
-    return fallback
-
-
-def _records_from_grounded(raw: str) -> List[Dict[str, str]]:
-    blocks = _parse_grounded_blocks(raw)
-    if not blocks:
-        return []
-
-    anchors: List[Dict[str, Any]] = []
-    for block in blocks:
-        voter_ids = find_voter_ids(block["text"])
-        if not voter_ids:
-            continue
-        for voter_id in voter_ids:
-            rec = empty_record()
-            rec["voter_id"] = voter_id
-            merge_record(rec, block["record"])
-            anchors.append({"voter_id": voter_id, "cx": block["cx"], "cy": block["cy"], "record": rec})
-
-    if not anchors:
-        # Retain readable details as rows, but don't invent missing IDs.
-        fallback = []
-        for block in blocks:
-            rec = block["record"]
-            if record_has_fields(rec):
-                fallback.append(rec)
-        return _deduplicate_records(fallback)
-
-    # Stable row-major reading order. Coordinates are normalized by DeepSeek-OCR
-    # to approximately a 0..1000 coordinate system.
-    anchors.sort(key=lambda anchor: (anchor["cy"], anchor["cx"]))
-    x_step = _median_step([a["cx"] for a in anchors], 1000.0)
-    y_step = _median_step([a["cy"] for a in anchors], 1000.0)
-    expected_detail_dx = 0.60 * x_step  # voter ID is often above/right of personal details
-    expected_down_dy = -0.35 * y_step  # ID tends to be higher on the same card
-
-    anchor_ids = {a["voter_id"] for a in anchors}
-    for block in blocks:
-        block_ids = find_voter_ids(block["text"])
-        if block_ids:
-            # IDs already created anchor rows. If this block also contains fields,
-            # merge its text with the matching row.
-            for voter_id in block_ids:
-                for anchor in anchors:
-                    if anchor["voter_id"] == voter_id:
-                        merge_record(anchor["record"], block["record"])
-                        break
-            continue
+                record = _record_from_text(cleaned_row, voter_id)
+                if record and voter_id not in seen:
+                    output.append(record)
+                    seen.add(voter_id)
+        elif ids:
+            id_only.extend(v for v in ids if v not in seen)
+        elif "नाम" in cleaned_row:
+            details_only.append(cleaned_row)
 
-        rec_fields = block["record"]
-        if not record_has_fields(rec_fields):
+    # Some OCR layouts put the ID and details in adjacent table cells/rows.
+    for voter_id, details in zip(id_only, details_only):
+        if voter_id in seen:
             continue
+        record = _record_from_text(details, voter_id)
+        if record:
+            output.append(record)
+            seen.add(voter_id)
 
-        is_photo = bool(rec_fields.get("photo_status")) and not any(
-            rec_fields.get(col) for col in ("name", "relative_name", "house_number", "age", "gender")
-        )
-        if len(anchors) == 1:
-            chosen = anchors[0]
-        else:
-            scored: List[Tuple[float, Dict[str, Any]]] = []
-            for anchor in anchors:
-                dx = anchor["cx"] - block["cx"]
-                dy = anchor["cy"] - block["cy"]
-                expected_dx = 0.0 if is_photo else expected_detail_dx
-                expected_dy = expected_down_dy
-                # Scale each axis by the inferred spacing between ID anchors.
-                sx = max(80.0, 0.55 * x_step)
-                sy = max(80.0, 0.55 * y_step)
-                score = abs(dx - expected_dx) / sx + abs(dy - expected_dy) / sy
-                scored.append((score, anchor))
-            chosen = min(scored, key=lambda item: item[0])[1]
-        merge_record(chosen["record"], rec_fields)
-
-    return _deduplicate_records([anchor["record"] for anchor in anchors])
-
-
-def _records_from_markdown_or_plain(raw: str) -> List[Dict[str, str]]:
-    """Fallback for Markdown tables or text output without grounded coordinates."""
-    raw = html.unescape(raw or "")
-    rows: List[str] = []
-    for row_match in HTML_ROW_RE.finditer(raw):
-        row = _clean_text(row_match.group(1))
-        if row:
-            rows.append(row)
-
-    # Markdown tables: parse a table line at a time, keeping all cells in the same row.
-    for line in raw.splitlines():
-        if "|" in line and re.search(r"[A-Za-z\u0900-\u097F]", line):
-            cells = [cell.strip() for cell in line.strip().strip("|").split("|")]
-            joined = "\n".join(_clean_text(cell) for cell in cells if cell.strip(" -:"))
-            if joined and not re.fullmatch(r"[-: |]+", joined):
-                rows.append(joined)
-
-    if not rows:
-        # Keep separated paragraphs distinct. This avoids assuming the whole page is one voter.
-        rows = [_clean_text(chunk) for chunk in re.split(r"\n\s*\n+", raw) if _clean_text(chunk)]
-
-    parsed_rows: List[Dict[str, str]] = []
-    id_only: List[str] = []
-    detail_only: List[Dict[str, str]] = []
-    for row in rows:
-        ids = find_voter_ids(row)
-        rec = parse_fields(row)
-        if ids and record_has_fields(rec):
-            for voter_id in ids:
-                new_rec = dict(rec)
-                new_rec["voter_id"] = voter_id
-                parsed_rows.append(new_rec)
-        elif ids:
-            id_only.extend(ids)
-        elif record_has_fields(rec):
-            detail_only.append(rec)
-
-    if id_only and detail_only:
-        for index, voter_id in enumerate(id_only):
-            rec = empty_record()
-            rec["voter_id"] = voter_id
-            if index < len(detail_only):
-                merge_record(rec, detail_only[index])
-            parsed_rows.append(rec)
-    else:
-        for voter_id in id_only:
-            rec = empty_record()
-            rec["voter_id"] = voter_id
-            parsed_rows.append(rec)
-        parsed_rows.extend(detail_only)
-
-    # Last-chance single-region parse; never copy one set of fields across many IDs.
-    if not parsed_rows:
-        rec = parse_fields(raw)
-        if rec.get("voter_id") or record_has_fields(rec):
-            parsed_rows.append(rec)
-
-    return _deduplicate_records(parsed_rows)
-
-
-def _deduplicate_records(records: Iterable[Dict[str, str]]) -> List[Dict[str, str]]:
-    output: List[Dict[str, str]] = []
-    by_id: Dict[str, Dict[str, str]] = {}
-    for original in records:
-        rec = empty_record()
-        for column in CSV_COLUMNS:
-            rec[column] = re.sub(r"\s+", " ", str(original.get(column, "") or "")).strip()
-        voter_id = rec.get("voter_id", "")
-        if voter_id:
-            if voter_id in by_id:
-                merge_record(by_id[voter_id], rec)
-            else:
-                by_id[voter_id] = rec
-                output.append(rec)
-        elif record_has_fields(rec):
-            output.append(rec)
     return output
 
 
-def parse_ocr_records(raw: str) -> List[Dict[str, str]]:
-    """Convert model output into one CSV record per detected voter ID/card."""
-    if not raw or not raw.strip():
-        return []
+def init_db() -> None:
+    db_parent = Path(DB_PATH).expanduser().resolve().parent
+    db_parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        conn.execute(
+            """CREATE TABLE IF NOT EXISTS voters (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                voter_id TEXT,
+                name TEXT,
+                father_name TEXT,
+                husband_name TEXT,
+                house_no TEXT,
+                age INTEGER,
+                gender TEXT,
+                raw_json TEXT
+            )"""
+        )
+        conn.commit()
+    finally:
+        conn.close()
 
-    html_records = _records_from_html(raw)
-    if html_records and any(record.get("voter_id") for record in html_records):
-        return html_records
 
-    grounded_records = _records_from_grounded(raw)
-    if grounded_records:
-        return grounded_records
+logger.info("Loading model: %s", MODEL_ID)
+logger.info("Torch version: %s | CUDA visible: %s", torch.__version__, torch.cuda.is_available())
 
-    return _records_from_markdown_or_plain(raw)
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
+load_device = "cuda" if torch.cuda.is_available() else "cpu"
+load_dtype = torch.bfloat16 if load_device == "cuda" else torch.float32
+model = AutoModel.from_pretrained(
+    MODEL_ID,
+    trust_remote_code=True,
+    use_safetensors=True,
+    _attn_implementation="eager",
+    torch_dtype=load_dtype,
+    low_cpu_mem_usage=True,
+).eval()
+model = model.to(load_device)
+logger.info("DeepSeek-OCR loaded on %s (%s).", load_device, load_dtype)
 
+# The model is shared by Gradio and Telegram, so serialize inference calls.
+_INFERENCE_LOCK = threading.Lock()
 
-# -----------------------------------------------------------------------------
-# GPU inference
-# -----------------------------------------------------------------------------
 
 @spaces.GPU(duration=GPU_DURATION_SECONDS)
-def run_ocr(image: Image.Image, profile_name: str = DEFAULT_PROFILE) -> str:
-    """Run one full-page OCR inference; Grounding/Gundam may use internal crops."""
-    if image is None:
-        raise ValueError("Please send or upload an image first.")
-
-    profile = (profile_name or DEFAULT_PROFILE).strip().lower()
-    if profile not in OCR_PROFILES:
-        profile = DEFAULT_PROFILE
-    config = OCR_PROFILES[profile]
-
-    # Normalize orientation/color, without shrinking or cropping the page.
-    page = ImageOps.exif_transpose(image).convert("RGB")
-    started = time.perf_counter()
-    with tempfile.TemporaryDirectory(prefix="deepseek_ocr_") as output_dir:
-        image_path = os.path.join(output_dir, "input_page.png")
-        page.save(image_path, format="PNG", optimize=True)
-        with torch.inference_mode():
-            result = MODEL.infer(
-                TOKENIZER,
-                prompt=OCR_PROMPT,
+def run_ocr(image_path: str, prompt: str = PROMPTS["Convert to Markdown"]) -> str:
+    """Run the model. The model is placed on the selected device at startup."""
+    output_dir = tempfile.TemporaryDirectory(prefix="deepseek_ocr_out_")
+    try:
+        with _INFERENCE_LOCK, torch.inference_mode():
+            result = model.infer(
+                tokenizer,
+                prompt=prompt,
                 image_file=image_path,
-                output_path=output_dir,
-                base_size=config["base_size"],
-                image_size=config["image_size"],
-                crop_mode=config["crop_mode"],
-                save_results=True,
+                output_path=output_dir.name,
+                base_size=1024,
+                image_size=640,
+                crop_mode=True,
+                save_results=False,
                 test_compress=True,
                 eval_mode=True,
             )
-    elapsed = time.perf_counter() - started
-    logger.info(
-        "OCR finished in %.1fs with profile=%s, base_size=%s, image_size=%s, crop_mode=%s",
-        elapsed, profile, config["base_size"], config["image_size"], config["crop_mode"],
-    )
-    return str(result or "").strip()
+        return result if isinstance(result, str) else str(result)
+    finally:
+        output_dir.cleanup()
 
 
-def records_to_csv_bytes(records: Sequence[Dict[str, str]]) -> bytes:
-    stream = io.StringIO(newline="")
-    writer = csv.DictWriter(stream, fieldnames=CSV_COLUMNS, extrasaction="ignore", lineterminator="\n")
-    writer.writeheader()
-    for record in records:
-        writer.writerow({column: record.get(column, "") for column in CSV_COLUMNS})
-    return stream.getvalue().encode("utf-8-sig")
-
-
-def save_csv_tempfile(records: Sequence[Dict[str, str]]) -> str:
-    data = records_to_csv_bytes(records)
-    with tempfile.NamedTemporaryFile(prefix="voter_records_", suffix=".csv", delete=False) as file_obj:
-        file_obj.write(data)
-        return file_obj.name
-
-
-def records_to_dataframe(records: Sequence[Dict[str, str]]) -> List[List[str]]:
-    return [[record.get(column, "") for column in CSV_COLUMNS] for record in records]
-
-
-def process_gradio_image(image: Optional[Image.Image], profile: str):
+def gradio_ocr(image: Image.Image | None, task: str) -> str:
     if image is None:
-        raise gr.Error("Upload a complete page image first.")
+        raise gr.Error("Upload an image first.")
+    prompt = PROMPTS.get(task, PROMPTS["Convert to Markdown"])
+    temp_path = None
     try:
-        raw = run_ocr(image, profile)
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as handle:
+            temp_path = handle.name
+        image.convert("RGB").save(temp_path, format="PNG")
+        return run_ocr(temp_path, prompt)
     except Exception as exc:
         logger.exception("Gradio OCR failed")
-        message = str(exc)
-        if "quota" in message.lower() or "duration" in message.lower() or "time limit" in message.lower():
-            raise gr.Error(
-                "The ZeroGPU request was rejected or timed out. Check GPU_DURATION_SECONDS and your remaining quota; "
-                "try OCR_PROFILE=tiny/small if the page still takes too long."
-            ) from exc
-        raise gr.Error(f"OCR failed: {message[:500]}") from exc
-
-    records = parse_ocr_records(raw)
-    csv_path = save_csv_tempfile(records) if records else None
-    if not records:
-        summary = (
-            "No complete voter records could be grouped automatically. The raw OCR output is shown above. "
-            "Try Gundam for a clearer scan, then verify the text/coordinates before relying on a CSV."
-        )
-    else:
-        incomplete = sum(1 for record in records if not record.get("voter_id") or not record.get("name"))
-        summary = f"Parsed {len(records)} row(s). {incomplete} row(s) are missing a voter ID or name and need manual review."
-    return raw, records_to_dataframe(records), csv_path, summary
+        raise gr.Error(f"OCR failed: {type(exc).__name__}: {exc}") from exc
+    finally:
+        if temp_path and os.path.exists(temp_path):
+            os.remove(temp_path)
 
 
-# -----------------------------------------------------------------------------
-# Telegram bot: send the original image as a document for best resolution.
-# -----------------------------------------------------------------------------
+def _authorized(update: Update) -> bool:
+    if ALLOWED_TELEGRAM_USER_IDS is None:
+        return True
+    user = update.effective_user
+    return user is not None and user.id in ALLOWED_TELEGRAM_USER_IDS
 
-_bot_thread: Optional[threading.Thread] = None
-_bot_lock = threading.Lock()
 
-
-def _telegram_error_message(exc: Exception) -> str:
-    message = str(exc).lower()
-    if "quota" in message or "duration" in message or "time limit" in message:
-        return (
-            "The OCR task reached or was refused by the GPU time/quota limit. "
-            "Try a clearer/smaller page or set OCR_PROFILE=tiny/small; increasing GPU_DURATION_SECONDS only works "
-            "when ZeroGPU permits that reservation and enough quota remains."
-        )
-    if "out of memory" in message or "cuda" in message:
-        return "The GPU could not complete this image. Try OCR_PROFILE=tiny/small or send a clearer, smaller page."
-    return "OCR could not finish this image. Please try again or send the image as a document for better resolution."
-
-
-async def telegram_start(update, context) -> None:
-    message = update.effective_message
-    if message:
-        await message.reply_text(
-            "Send one full-page electoral-roll image. I will OCR it and return a CSV file.\n\n"
-            "For best quality, send the page as a document/file so Telegram does not resize it. "
-            f"Current profile: {DEFAULT_PROFILE}."
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    if not _authorized(update):
+        if update.effective_message:
+            await update.effective_message.reply_text("This bot is not enabled for your account.")
+        return
+    if update.effective_message:
+        await update.effective_message.reply_text(
+            "Send an image as a photo or image document. I will run DeepSeek-OCR and, "
+            "when voter-style rows are detected, return a CSV for you to review. "
+            "Use the Save button only after checking the extracted data."
         )
 
 
-async def telegram_help(update, context) -> None:
+async def on_image(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     message = update.effective_message
-    if message:
-        await message.reply_text(
-            "How to use:\n"
-            "1. Send a clear image of one complete page.\n"
-            "2. Prefer sending it as a document/file to preserve resolution.\n"
-            "3. The bot returns voter_records.csv with voter ID, name, relative name/type, house number, age, gender and photo status.\n\n"
-            "Review the CSV before use: complex page layouts can cause OCR/grouping errors."
-        )
+    if message is None:
+        return
+    if not _authorized(update):
+        await message.reply_text("This bot is not enabled for your account.")
+        return
 
+    document = message.document
+    photo = message.photo
+    if document:
+        mime_type = document.mime_type or ""
+        if not mime_type.startswith("image/"):
+            await message.reply_text("Please send an image file (PNG, JPG, or similar).")
+            return
+        file_id = document.file_id
+        original_name = document.file_name or "upload.png"
+        file_size = document.file_size
+    elif photo:
+        file_id = photo[-1].file_id
+        original_name = f"telegram_{message.message_id}.jpg"
+        file_size = photo[-1].file_size
+    else:
+        return
 
-async def _download_image_from_telegram(update, context) -> Optional[Image.Image]:
-    message = update.effective_message
-    if not message:
-        return None
+    if file_size and file_size > MAX_TELEGRAM_FILE_BYTES:
+        await message.reply_text("This image is too large. Please send one under 20 MB.")
+        return
 
-    telegram_file = None
-    if message.photo:
-        telegram_file = await context.bot.get_file(message.photo[-1].file_id)
-    elif message.document:
-        document = message.document
-        file_name = (document.file_name or "").lower()
-        mime_type = (document.mime_type or "").lower()
-        if not (mime_type.startswith("image/") or file_name.endswith((".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff"))):
-            await message.reply_text("Please send a JPG, PNG, WEBP, BMP, or TIFF image. For best quality, send it as a document.")
-            return None
-        telegram_file = await context.bot.get_file(document.file_id)
-    if telegram_file is None:
-        return None
+    suffix = Path(original_name).suffix.lower()
+    if suffix not in {".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff"}:
+        suffix = ".jpg"
+    local_path = None
+    status = await message.reply_text("Image received. Running DeepSeek-OCR…")
 
-    buffer = io.BytesIO()
-    await telegram_file.download_to_memory(buffer)
-    buffer.seek(0)
     try:
-        image = Image.open(buffer)
-        image.load()
-        return ImageOps.exif_transpose(image).convert("RGB")
-    except Exception as exc:
-        logger.warning("Telegram attachment was not a readable image: %s", exc)
-        await message.reply_text("I could not open this image. Try sending it as a JPG or PNG file.")
-        return None
-
-
-async def _process_telegram_image(update, context) -> None:
-    message = update.effective_message
-    if not message:
-        return
-    image = await _download_image_from_telegram(update, context)
-    if image is None:
-        return
+        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as handle:
+            local_path = handle.name
+        telegram_file = await context.bot.get_file(file_id)
+        await telegram_file.download_to_drive(custom_path=local_path)
+
+        raw = await asyncio.to_thread(run_ocr, local_path, PROMPTS["Convert to Markdown"])
+        records = parse_markdown(raw)
+        if not records:
+            await status.edit_text("OCR finished, but I could not confidently parse voter-style rows. Raw OCR follows:")
+            await message.reply_text(raw[:3500] or "The model returned no text.")
+            return
 
-    await message.reply_text(f"Processing the complete page with profile '{DEFAULT_PROFILE}'…")
-    try:
-        # Keep the Telegram event loop responsive while the GPU call is running.
-        raw = await asyncio.to_thread(run_ocr, image, DEFAULT_PROFILE)
-        records = parse_ocr_records(raw)
-        if records:
-            csv_stream = io.BytesIO(records_to_csv_bytes(records))
-            csv_stream.name = "voter_records.csv"
-            incomplete = sum(1 for record in records if not record.get("voter_id") or not record.get("name"))
-            caption = f"Extracted {len(records)} row(s). Rows needing review: {incomplete}. Please verify against the original page."
-            await message.reply_document(
-                document=csv_stream,
-                filename="voter_records.csv",
-                caption=caption,
+        csv_path = os.path.join(tempfile.gettempdir(), f"deepseek_{uuid.uuid4().hex}.csv")
+        with open(csv_path, "w", newline="", encoding="utf-8-sig") as csv_file:
+            writer = csv.DictWriter(
+                csv_file,
+                fieldnames=["voter_id", "name", "father_name", "husband_name", "house_no", "age", "gender"],
             )
-        else:
-            raw_stream = io.BytesIO((raw or "No text was returned by the OCR model.").encode("utf-8"))
-            raw_stream.name = "ocr_raw_output.txt"
-            await message.reply_text(
-                "I could not reliably group the result into voter records, so I have not guessed the CSV rows. "
-                "Here is the raw OCR output for inspection. Try a full-resolution document upload or another profile."
+            writer.writeheader()
+            writer.writerows(records)
+
+        context.user_data["csv_path"] = csv_path
+        context.user_data["records"] = records
+        keyboard = InlineKeyboardMarkup(
+            [[
+                InlineKeyboardButton("✅ Save to database", callback_data="save"),
+                InlineKeyboardButton("❌ Cancel", callback_data="cancel"),
+            ]]
+        )
+        await status.edit_text(f"OCR finished. Found {len(records)} possible records; review the CSV before saving.")
+        with open(csv_path, "rb") as csv_file:
+            await message.reply_document(
+                document=csv_file,
+                filename="extracted_records.csv",
+                caption=f"{len(records)} possible records. Verify the CSV before saving.",
+                reply_markup=keyboard,
             )
-            await message.reply_document(document=raw_stream, filename="ocr_raw_output.txt")
     except Exception as exc:
-        logger.exception("Telegram OCR request failed")
-        await message.reply_text(_telegram_error_message(exc))
-
+        logger.exception("Telegram OCR pipeline failed")
+        try:
+            await status.edit_text(f"OCR failed: {type(exc).__name__}. Check the Space logs for details.")
+        except Exception:
+            await message.reply_text(f"OCR failed: {type(exc).__name__}. Check the Space logs for details.")
+    finally:
+        if local_path and os.path.exists(local_path):
+            os.remove(local_path)
+
+
+async def on_button(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    query = update.callback_query
+    if query is None:
+        return
+    await query.answer()
+    if not _authorized(update):
+        await query.edit_message_caption(caption="This bot is not enabled for your account.")
+        return
 
-async def telegram_photo(update, context) -> None:
-    await _process_telegram_image(update, context)
+    csv_path = context.user_data.get("csv_path")
+    records = context.user_data.get("records")
+    try:
+        if query.data == "save" and records:
+            conn = sqlite3.connect(DB_PATH)
+            try:
+                conn.executemany(
+                    """INSERT INTO voters
+                    (voter_id, name, father_name, husband_name, house_no, age, gender, raw_json)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+                    [
+                        (
+                            row["voter_id"], row["name"], row["father_name"],
+                            row["husband_name"], row["house_no"], row["age"],
+                            row["gender"], json.dumps(row, ensure_ascii=False),
+                        )
+                        for row in records
+                    ],
+                )
+                conn.commit()
+            finally:
+                conn.close()
+            await query.edit_message_caption(caption=f"Saved {len(records)} records to the local database.")
+        elif query.data == "cancel":
+            await query.edit_message_caption(caption="Cancelled. No records were saved.")
+    except Exception:
+        logger.exception("Could not save/cancel records")
+        await query.edit_message_caption(caption="Could not complete that action. Check the Space logs.")
+    finally:
+        if csv_path and os.path.exists(csv_path):
+            os.remove(csv_path)
+        context.user_data.pop("csv_path", None)
+        context.user_data.pop("records", None)
 
 
-async def telegram_document(update, context) -> None:
-    await _process_telegram_image(update, context)
+async def telegram_error(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
+    logger.error("Telegram handler error", exc_info=context.error)
 
 
-def _telegram_worker() -> None:
-    # Imports live here so the Gradio UI can start even when PTB isn't installed.
-    try:
-        from telegram import error as telegram_error
-        from telegram.ext import Application, CommandHandler, MessageHandler, filters
-    except Exception:
-        logger.exception("python-telegram-bot is not installed; Telegram bot is disabled")
+def start_telegram_bot() -> None:
+    """Start the bot using long polling; no inbound webhook route is needed."""
+    if not TELEGRAM_BOT_TOKEN:
+        logger.warning("TELEGRAM_BOT_TOKEN is not set; Telegram integration is disabled.")
         return
 
-    #application = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
-    from telegram.request import HTTPXRequest
-    telegram_request = HTTPXRequest(
-        connect_timeout=30,
-        read_timeout=30,
-        write_timeout=30,
-        pool_timeout=30,
-        )
-    application = (
-        Application.builder()
-        .token(TELEGRAM_BOT_TOKEN)
-        .request(telegram_request)
-        .build()
-         )
-    application.add_handler(CommandHandler("start", telegram_start))
-    application.add_handler(CommandHandler("help", telegram_help))
-    application.add_handler(MessageHandler(filters.PHOTO, telegram_photo))
-    application.add_handler(MessageHandler(filters.Document.ALL, telegram_document))
-
-    logger.warning("Starting Telegram polling in PID=%s (once per app process)", os.getpid())
-    try:
-        # run_polling normally installs signal handlers, which is not allowed in a thread.
-        application.run_polling(drop_pending_updates=True, stop_signals=None)
-    except telegram_error.Conflict:
-        logger.error(
-            "Telegram polling conflict: another process is already using getUpdates for this bot token. "
-            "Stop any other bot instance and keep only one active polling process."
-        )
-    except Exception:
-        logger.exception("Telegram bot stopped unexpectedly")
+    bot_app = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
+    bot_app.add_handler(CommandHandler("start", start))
+    bot_app.add_handler(
+        MessageHandler((filters.PHOTO | filters.Document.IMAGE) & ~filters.COMMAND, on_image)
+    )
+    bot_app.add_handler(CallbackQueryHandler(on_button))
+    bot_app.add_error_handler(telegram_error)
 
+    async def worker() -> None:
+        await bot_app.initialize()
+        # Polling and webhook modes cannot run at the same time. Clear any old webhook.
+        await bot_app.bot.delete_webhook(drop_pending_updates=False)
+        assert bot_app.updater is not None
+        await bot_app.updater.start_polling(drop_pending_updates=False)
+        await bot_app.start()
+        logger.info("Telegram bot started in long-polling mode.")
+        await asyncio.Event().wait()
 
-def start_telegram_bot_once() -> None:
-    global _bot_thread
-    if not TELEGRAM_BOT_TOKEN:
-        logger.info("TELEGRAM_BOT_TOKEN/BOT_TOKEN is not set; starting Gradio UI without Telegram")
-        return
-    with _bot_lock:
-        if _bot_thread is not None and _bot_thread.is_alive():
-            logger.info("Telegram polling thread already started in this process; skipping duplicate start")
-            return
-        _bot_thread = threading.Thread(target=_telegram_worker, name="telegram-polling", daemon=True)
-        _bot_thread.start()
+    def thread_target() -> None:
+        try:
+            asyncio.run(worker())
+        except Exception:
+            logger.exception("Telegram bot failed to start. Check TELEGRAM_BOT_TOKEN and polling conflicts.")
+
+    threading.Thread(target=thread_target, daemon=True, name="telegram-polling").start()
 
 
-# -----------------------------------------------------------------------------
-# Gradio UI
-# -----------------------------------------------------------------------------
+init_db()
+start_telegram_bot()
 
-with gr.Blocks(title="DeepSeek-OCR — Full Page to CSV") as demo:
+with gr.Blocks(title="DeepSeek-OCR") as demo:
     gr.Markdown(
-        "# DeepSeek-OCR: Full page to CSV\n"
-        "Upload one complete page. The app makes one OCR inference call, groups detected fields into rows, "
-        "and creates a UTF-8 CSV. For smaller text, try **Gundam** and send the original image as a document in Telegram."
+        "# DeepSeek-OCR\n"
+        "Upload an image for OCR. The same model is available through Telegram when "
+        "`TELEGRAM_BOT_TOKEN` is configured in Space secrets."
     )
     with gr.Row():
-        with gr.Column(scale=1):
-            image_input = gr.Image(type="pil", label="Complete page image", sources=["upload", "clipboard"])
-            profile_input = gr.Dropdown(
-                choices=["tiny", "small", "base", "large", "gundam"],
-                value=DEFAULT_PROFILE,
-                label="OCR profile",
-                info="Gundam uses internal crops for detail; Tiny/Small are faster but may miss small text.",
+        with gr.Column():
+            image_input = gr.Image(type="pil", label="Image", sources=["upload", "clipboard"])
+            task_input = gr.Dropdown(
+                choices=list(PROMPTS.keys()),
+                value="Convert to Markdown",
+                label="OCR task",
             )
-            run_button = gr.Button("OCR full page and create CSV", variant="primary")
-        with gr.Column(scale=2):
-            summary_output = gr.Textbox(label="Result summary", lines=2, interactive=False)
-            table_output = gr.Dataframe(
-                headers=CSV_COLUMNS,
-                datatype=["str"] * len(CSV_COLUMNS),
-                label="Parsed CSV rows — review before use",
-                interactive=False,
-                wrap=True,
-            )
-            csv_output = gr.File(label="Download CSV")
-    raw_output = gr.Textbox(label="Raw OCR output (for troubleshooting)", lines=12, max_lines=30, interactive=False)
+            run_button = gr.Button("Run OCR", variant="primary")
+        with gr.Column():
+            output_text = gr.Textbox(label="OCR output", lines=18, show_copy_button=True)
+    run_button.click(fn=gradio_ocr, inputs=[image_input, task_input], outputs=output_text)
     gr.Markdown(
-        "**Important:** OCR and row grouping can make mistakes, especially when cards are close together or text is blurry. "
-        "Verify names, voter IDs and row associations against the source page."
-    )
-    run_button.click(
-        fn=process_gradio_image,
-        inputs=[image_input, profile_input],
-        outputs=[raw_output, table_output, csv_output, summary_output],
+        "**Note:** OCR can be inaccurate. Verify any extracted identity or demographic information "
+        "before using or storing it. The local SQLite database may be lost when the Space restarts "
+        "unless you have separately configured persistent storage."
     )
 
-
 if __name__ == "__main__":
-    start_telegram_bot_once()
-    demo.queue(max_size=6).launch(server_name="0.0.0.0", ssr_mode=False)
+    demo.queue(max_size=8).launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)

requirements.txt

@@ -1,4 +1,4 @@
-# Gradio is provided by the Space SDK version in README.md (5.49.1).
+# Keep this stack aligned with the DeepSeek-OCR Transformers 4.57.6 model card.
 transformers==4.57.6
 tokenizers==0.22.2
 accelerate>=0.33,<2.0
@@ -15,4 +15,3 @@ pymupdf
 python-telegram-bot>=22.0,<23.0
 httpx>=0.27,<1.0
 huggingface-hub>=0.34.0,<1.0
-spaces>=0.30.0