Delete app.py

app.py

@@ -1,694 +0,0 @@
-# ─────────────────────────────────────────────────────────────
-# 0. HfFolder shim (must be first executable code)
-# ─────────────────────────────────────────────────────────────
-import huggingface_hub
-if not hasattr(huggingface_hub, "HfFolder"):
-    class _HfFolder:
-        @staticmethod
-        def get_token(): return huggingface_hub.get_token()
-        @staticmethod
-        def save_token(token): huggingface_hub.login(token)
-        @staticmethod
-        def delete_token(): huggingface_hub.logout()
-    huggingface_hub.HfFolder = _HfFolder
-
-# ─────────────────────────────────────────────────────────────
-# 1. Imports
-# ─────────────────────────────────────────────────────────────
-import os
-import re
-import time
-import html
-import asyncio
-import logging
-import threading
-from typing import Optional
-
-import httpx
-from fastapi import Request
-from fastapi.responses import JSONResponse
-from starlette.routing import Route as StarletteRoute
-import gradio as gr
-import spaces
-
-# ─────────────────────────────────────────────────────────────
-# 2. Config
-# ─────────────────────────────────────────────────────────────
-BOT_TOKEN      = os.environ["BOT_TOKEN"]
-WEBHOOK_SECRET = os.environ.get("WEBHOOK_SECRET", "1221")
-SPACE_URL      = os.environ["SPACE_URL"].rstrip("/")
-TELEGRAM_PROXY = os.environ.get("TELEGRAM_PROXY", "").rstrip("/")
-
-ADMIN_IDS      = [int(x) for x in os.environ.get("ADMIN_IDS", "").split(",") if x.strip().isdigit()]
-AUTH_ENABLED   = len(ADMIN_IDS) > 0
-
-TG_API = (TELEGRAM_PROXY + "/bot" + BOT_TOKEN) if TELEGRAM_PROXY \
-         else f"https://api.telegram.org/bot{BOT_TOKEN}"
-
-RATE_LIMIT_SEC = 5
-PAGE_SIZE      = 4
-QUERY_TIMEOUT  = 45
-HTTP_TIMEOUT   = httpx.Timeout(45.0, connect=10.0)
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-log = logging.getLogger("bot")
-
-# ─────────────────────────────────────────────────────────────
-# 3. HTTP clients (one AsyncClient per running event loop)
-# ─────────────────────────────────────────────────────────────
-_api_clients: dict[int, httpx.AsyncClient] = {}
-_clients_lock = threading.Lock()
-
-
-async def _get_api_client() -> httpx.AsyncClient:
-    loop = asyncio.get_running_loop()
-    key = id(loop)
-    client = _api_clients.get(key)
-    if client is None or client.is_closed:
-        client = httpx.AsyncClient(timeout=HTTP_TIMEOUT, follow_redirects=True)
-        with _clients_lock:
-            _api_clients[key] = client
-    return client
-
-
-# ─────────────────────────────────────────────────────────────
-# 4. External data sources
-# ─────────────────────────────────────────────────────────────
-def _clean(v):
-    """Strip 'null', 'N/A', empty strings → return None."""
-    if v is None:
-        return None
-    s = str(v).strip()
-    if s in ("", "null", "N/A", "None", "-"):
-        return None
-    return s
-
-
-async def _q_cr850(client: httpx.AsyncClient, number: str) -> list[dict]:
-    url = f"https://sauravsingh2111-850crfastsearch.hf.space/search/{number}"
-    try:
-        r = await client.get(url, timeout=35.0)
-        if r.status_code != 200:
-            log.info("cr850 → %s", r.status_code)
-            return []
-        data = r.json()
-        if not data.get("success") or not data.get("results"):
-            return []
-        out = []
-        for item in data["results"]:
-            addr = item.get("address") or {}
-            full = None
-            if isinstance(addr, dict):
-                full = addr.get("full_address")
-                if full:
-                    full = full.lstrip(", ").strip()
-            out.append({
-                "source": "850CR Fast",
-                "fields": {
-                    "Name":       _clean(item.get("name")),
-                    "Father":     _clean(item.get("father_name")),
-                    "Address":    _clean(full),
-                    "Alternate":  _clean(item.get("alternate_number")),
-                    "Circle":     _clean(item.get("circle")),
-                    "Operator":   _clean(item.get("operator")),
-                    "State":      _clean(item.get("state")),
-                    "Email":      _clean(item.get("email")),
-                },
-            })
-        return out
-    except Exception as e:
-        log.warning("cr850 failed: %s", e)
-        return []
-
-
-async def _q_inddata(client: httpx.AsyncClient, number: str) -> list[dict]:
-    url = "https://tfqdeadlo-inddataapi.hf.space/search"
-    try:
-        r = await client.get(url, params={"mobile": number}, timeout=25.0)
-        if r.status_code != 200:
-            log.info("inddata → %s", r.status_code)
-            return []
-        data = r.json()
-        rows = data.get("data") if isinstance(data, dict) else None
-        if not isinstance(rows, list):
-            return []
-        out = []
-        for item in rows:
-            out.append({
-                "source": "IndData 1.4B",
-                "fields": {
-                    "Mobile":   _clean(item.get("mobile")),
-                    "Name":     _clean(item.get("name")),
-                    "Father":   _clean(item.get("fname")),
-                    "Address":  _clean(item.get("address")),
-                    "Email":    _clean(item.get("email")),
-                    "ID":       _clean(item.get("id")),
-                },
-            })
-        return out
-    except Exception as e:
-        log.warning("inddata failed: %s", e)
-        return []
-
-
-async def _q_hiteck_main(client: httpx.AsyncClient, number: str) -> list[dict]:
-    url = "https://hiteckgroup-hiteckgroup.hf.space/search"
-    try:
-        r = await client.get(url, params={"mobile": number}, timeout=25.0)
-        if r.status_code != 200:
-            log.info("hiteck_main → %s", r.status_code)
-            return []
-        data = r.json()
-        rows = data.get("data") if isinstance(data, dict) else None
-        if not isinstance(rows, list):
-            return []
-        out = []
-        for item in rows:
-            addr = item.get("address")
-            if addr:
-                addr = addr.replace("!", ", ")
-            out.append({
-                "source": "HiTeck 1.78B",
-                "fields": {
-                    "Mobile":   _clean(item.get("mobile")),
-                    "Name":     _clean(item.get("name")),
-                    "Father":   _clean(item.get("fname")),
-                    "Address":  _clean(addr),
-                    "Alternate": _clean(item.get("alt")),
-                    "Circle":   _clean(item.get("circle")),
-                    "Email":    _clean(item.get("email")),
-                },
-            })
-        return out
-    except Exception as e:
-        log.warning("hiteck_main failed: %s", e)
-        return []
-
-
-async def _q_hiteck_big(client: httpx.AsyncClient, number: str) -> list[dict]:
-    url = "https://hiteckgroup-hiteckgroupp.hf.space/search"
-    try:
-        r = await client.get(url, params={"q": number}, timeout=30.0)
-        if r.status_code != 200:
-            log.info("hiteck_big → %s", r.status_code)
-            return []
-        data = r.json()
-        rows = data.get("results") if isinstance(data, dict) else None
-        if not isinstance(rows, list):
-            return []
-        out = []
-        for item in rows:
-            out.append({
-                "source": "HiTeck 5B",
-                "fields": {
-                    "Name":       _clean(item.get("name")),
-                    "Father":     _clean(item.get("fathersName")),
-                    "Phone":      _clean(item.get("phoneNumber")),
-                    "Aadhaar":    _clean(item.get("aadharNumber")),
-                    "Other":      _clean(item.get("otherNumber")),
-                    "Address":    _clean(item.get("address")),
-                    "District":   _clean(item.get("district")),
-                    "State":      _clean(item.get("state")),
-                    "Town":       _clean(item.get("town")),
-                    "Pincode":    _clean(item.get("pincode")),
-                    "Source":     _clean(item.get("source")),
-                },
-            })
-        return out
-    except Exception as e:
-        log.warning("hiteck_big failed: %s", e)
-        return []
-
-
-# ─────────────────────────────────────────────────────────────
-# 4b. De-duplication
-# ─────────────────────────────────────────────────────────────
-def _norm(s) -> str:
-    """Lowercase, strip, collapse whitespace."""
-    if not s:
-        return ""
-    return re.sub(r"\s+", " ", str(s).strip().lower())
-
-
-def _dedup_key(rec: dict):
-    """Build a fingerprint for dedup. Returns None if the record can't be keyed."""
-    f = rec.get("fields", {})
-    name = _norm(f.get("Name"))
-    father = _norm(f.get("Father"))
-    if name or father:
-        return ("nf", name, father)
-    addr = _norm(f.get("Address"))
-    if addr:
-        addr = re.sub(r"[^a-z0-9]+", " ", addr).strip()
-        if addr:
-            return ("a", addr)
-    return None
-
-
-def _dedup(records: list[dict]) -> list[dict]:
-    """Remove duplicates. Keeps the record with the most non-null fields."""
-    seen: dict = {}          # key -> index in `result`
-    result: list[dict] = []
-
-    for rec in records:
-        key = _dedup_key(rec)
-        if key is None:
-            # Can't dedup — keep as-is
-            result.append(rec)
-            continue
-
-        idx = seen.get(key)
-        if idx is None:
-            seen[key] = len(result)
-            result.append(rec)
-        else:
-            # Collision: keep the record with more populated fields
-            existing = result[idx]
-            if len(rec.get("fields", {})) > len(existing.get("fields", {})):
-                result[idx] = rec
-
-    return result
-
-
-async def search_phone(number: str) -> list[dict]:
-    """Query all 4 APIs in parallel, merge, and de-duplicate."""
-    client = await _get_api_client()
-    tasks = [
-        _q_cr850(client, number),
-        _q_inddata(client, number),
-        _q_hiteck_main(client, number),
-        _q_hiteck_big(client, number),
-    ]
-    chunks = await asyncio.gather(*tasks, return_exceptions=True)
-
-    merged: list[dict] = []
-    for chunk in chunks:
-        if isinstance(chunk, list):
-            merged.extend(chunk)
-
-    before = len(merged)
-    deduped = _dedup(merged)
-    after = len(deduped)
-    if before != after:
-        log.info("Dedup: %d → %d (removed %d duplicates)", before, after, before - after)
-
-    return deduped
-
-
-# ─────────────────────────────────────────────────────────────
-# 5. Telegram API helpers
-# ─────────────────────────────────────────────────────────────
-async def tg(method: str, **payload):
-    client = await _get_api_client()
-    url = f"{TG_API}/{method}"
-    r = await client.post(url, json=payload)
-    if r.status_code >= 400:
-        log.warning("Telegram %s failed: %s %s", method, r.status_code, r.text[:200])
-    try:
-        return r.json()
-    except Exception:
-        return {}
-
-
-async def send(chat_id: int, text: str, **kw):
-    kw.setdefault("parse_mode", "HTML")
-    kw.setdefault("disable_web_page_preview", True)
-    try:
-        return await tg("sendMessage", chat_id=chat_id, text=text, **kw)
-    except Exception:
-        log.exception("send failed")
-        return {}
-
-
-async def edit(chat_id: int, message_id: int, text: str, **kw):
-    kw.setdefault("parse_mode", "HTML")
-    kw.setdefault("disable_web_page_preview", True)
-    try:
-        return await tg("editMessageText", chat_id=chat_id, message_id=message_id, text=text, **kw)
-    except Exception:
-        log.exception("edit failed")
-        return {}
-
-
-async def answer_callback(callback_id: str, **kw):
-    try:
-        return await tg("answerCallbackQuery", callback_query_id=callback_id, **kw)
-    except Exception:
-        log.exception("answer_callback failed")
-        return {}
-
-
-# ─────────────────────────────────────────────────────────────
-# 6. Formatting
-# ─────────────────────────────────────────────────────────────
-def _esc(v) -> str:
-    return html.escape(str(v)) if v is not None else ""
-
-
-def render_record(rec: dict) -> str:
-    src = _esc(rec.get("source", "Unknown"))
-    fields = rec.get("fields", {})
-    lines = [f"🗂 <b>{src}</b>"]
-    for k, v in fields.items():
-        if v is None or v == "":
-            continue
-        lines.append(f"• <b>{_esc(k)}:</b> {_esc(v)}")
-    if len(lines) == 1:
-        lines.append("• <i>no data</i>")
-    return "\n".join(lines)
-
-
-def render_page(number: str, records: list[dict], page: int) -> str:
-    total = len(records)
-    start = page * PAGE_SIZE
-    chunk = records[start:start + PAGE_SIZE]
-    if not chunk:
-        return "No more results."
-    pages = (total - 1) // PAGE_SIZE + 1
-    header = (
-        f"🔎 <b>Results for</b> <code>{_esc(number)}</code>  —  "
-        f"page {page + 1}/{pages}  ({total} record{'s' if total != 1 else ''})\n\n"
-    )
-    body = "\n\n━━━━━━━━━━━━━━━━━━\n\n".join(render_record(r) for r in chunk)
-    return header + body
-
-
-def pagination_kb(number: str, page: int, total: int):
-    nav = []
-    if page > 0:
-        nav.append({"text": "◀ Prev", "callback_data": f"pg|{number}|{page - 1}"})
-    if (page + 1) * PAGE_SIZE < total:
-        nav.append({"text": "Next ▶", "callback_data": f"pg|{number}|{page + 1}"})
-    return {"inline_keyboard": [nav]} if nav else None
-
-
-# ─────────────────────────────────────────────────────────────
-# 7. Per-user state
-# ─────────────────────────────────────────────────────────────
-_last_search: dict[int, float] = {}
-_search_lock = threading.Lock()
-
-_admin_states: dict[int, str] = {}
-_authorized_users: set[int] = set()
-_custom_apis: list[str] = []
-_admin_lock = threading.Lock()
-
-
-# ─────────────────────────────────────────────────────────────
-# 8. Admin helpers
-# ─────────────────────────────────────────────────────────────
-def _is_admin(user_id: int) -> bool:
-    return user_id in ADMIN_IDS
-
-
-def _is_authorized(user_id: int) -> bool:
-    if not AUTH_ENABLED:
-        return True
-    with _admin_lock:
-        return user_id in _authorized_users or _is_admin(user_id)
-
-
-def _admin_menu_kb():
-    return {
-        "inline_keyboard": [
-            [{"text": "➕ Add User", "callback_data": "admin|add_user"}],
-            [{"text": "➖ Remove User", "callback_data": "admin|remove_user"}],
-            [{"text": "📋 List Users", "callback_data": "admin|list_users"}],
-            [{"text": "🔌 Add API", "callback_data": "admin|add_api"}],
-            [{"text": "🗑 Clear APIs", "callback_data": "admin|clear_apis"}],
-            [{"text": "📋 List APIs", "callback_data": "admin|list_apis"}],
-        ]
-    }
-
-
-# ─────────────────────────────────────────────────────────────
-# 9. Message handlers
-# ─────────────────────────────────────────────────────────────
-async def handle_message(update: dict):
-    msg = update.get("message") or update.get("edited_message")
-    if not msg:
-        return
-    chat_id = msg["chat"]["id"]
-    user_id = msg["from"]["id"]
-    text = (msg.get("text") or "").strip()
-
-    # Admin input capture
-    with _admin_lock:
-        state = _admin_states.get(user_id)
-    if state and _is_admin(user_id):
-        if state == "await_user_id":
-            if text.isdigit():
-                with _admin_lock:
-                    _authorized_users.add(int(text))
-                    _admin_states.pop(user_id, None)
-                await send(chat_id, f"✅ User <code>{text}</code> authorized.")
-            else:
-                await send(chat_id, "❗ Send a numeric Telegram user ID.")
-            return
-        if state == "await_api_url":
-            if text.startswith("http"):
-                with _admin_lock:
-                    _custom_apis.append(text.rstrip("/"))
-                    _admin_states.pop(user_id, None)
-                await send(chat_id, f"✅ API added: <code>{_esc(text)}</code>")
-            else:
-                await send(chat_id, "❗ Send a valid http(s) URL.")
-            return
-
-    # Commands
-    if text.startswith("/"):
-        cmd = text.split()[0].lower()
-
-        if cmd == "/start":
-            await send(
-                chat_id,
-                "👋 <b>Welcome!</b>\n\n"
-                "Send me a <b>10‑digit mobile number</b> and I'll search across multiple databases.\n\n"
-                "Commands:\n"
-                "/start — this message\n"
-                "/status — bot health\n"
-                "/myid — show your Telegram user ID",
-            )
-            return
-
-        if cmd == "/myid":
-            await send(chat_id, f"🆔 Your Telegram user ID: <code>{user_id}</code>")
-            return
-
-        if cmd == "/status":
-            await send(
-                chat_id,
-                "✅ <b>Bot alive</b>\n"
-                f"🗂 Sources: 4 (dedup ON)\n"
-                f"⏱ Rate limit: {RATE_LIMIT_SEC}s\n"
-                f"📄 Page size: {PAGE_SIZE}",
-            )
-            return
-
-        if cmd == "/nemesis":
-            if not _is_admin(user_id):
-                await send(chat_id, "⛔ Unauthorized.")
-                return
-            await send(chat_id, "🛡 <b>Admin Panel</b>\nChoose an action:", reply_markup=_admin_menu_kb())
-            return
-
-        return
-
-    if not _is_authorized(user_id):
-        await send(chat_id, "⛔ You are not authorized to use this bot.")
-        return
-
-    if not (text.isdigit() and len(text) == 10):
-        await send(chat_id, "❗ Please send a <b>10‑digit mobile number</b> only.")
-        return
-
-    now = time.time()
-    with _search_lock:
-        last = _last_search.get(chat_id, 0)
-        if now - last < RATE_LIMIT_SEC:
-            wait = int(RATE_LIMIT_SEC - (now - last)) + 1
-            await send(chat_id, f"⏳ Please wait <b>{wait}s</b> before searching again.")
-            return
-        _last_search[chat_id] = now
-
-    await send(chat_id, f"🔍 <b>Searching</b> <code>{_esc(text)}</code> across 4 databases …")
-
-    try:
-        records = await asyncio.wait_for(search_phone(text), timeout=QUERY_TIMEOUT)
-    except asyncio.TimeoutError:
-        await send(chat_id, "⏰ Search timed out. Try again in a moment.")
-        return
-    except Exception:
-        log.exception("search_phone unexpected error")
-        await send(chat_id, "⚠️ Unexpected error during search.")
-        return
-
-    if not records:
-        await send(chat_id, f"❌ No records found for <code>{_esc(text)}</code>.")
-        return
-
-    kb = pagination_kb(text, 0, len(records))
-    await send(chat_id, render_page(text, records, 0), reply_markup=kb)
-
-
-async def handle_callback(update: dict):
-    cb = update.get("callback_query")
-    if not cb:
-        return
-    data = cb.get("data") or ""
-    chat_id = cb["message"]["chat"]["id"]
-    user_id = cb["from"]["id"]
-    message_id = cb["message"]["message_id"]
-    await answer_callback(cb["id"])
-
-    if data.startswith("admin|"):
-        if not _is_admin(user_id):
-            await edit(chat_id, message_id, "⛔ Unauthorized.")
-            return
-        action = data.split("|", 1)[1]
-
-        if action == "add_user":
-            with _admin_lock:
-                _admin_states[user_id] = "await_user_id"
-            await edit(chat_id, message_id, "Send the Telegram user ID to authorize:")
-            return
-
-        if action == "remove_user":
-            with _admin_lock:
-                users = sorted(_authorized_users)
-            if not users:
-                await edit(chat_id, message_id, "No authorized users.", reply_markup=_admin_menu_kb())
-            else:
-                txt = "Authorized users:\n" + "\n".join(f"<code>{u}</code>" for u in users)
-                await edit(chat_id, message_id, txt, reply_markup=_admin_menu_kb())
-            return
-
-        if action == "list_users":
-            with _admin_lock:
-                users = sorted(_authorized_users)
-            txt = "Authorized users:\n" + ("\n".join(f"<code>{u}</code>" for u in users) if users else "—")
-            await edit(chat_id, message_id, txt, reply_markup=_admin_menu_kb())
-            return
-
-        if action == "add_api":
-            with _admin_lock:
-                _admin_states[user_id] = "await_api_url"
-            await edit(chat_id, message_id, "Send the API base URL to add:")
-            return
-
-        if action == "clear_apis":
-            with _admin_lock:
-                _custom_apis.clear()
-            await edit(chat_id, message_id, "✅ All custom APIs cleared.", reply_markup=_admin_menu_kb())
-            return
-
-        if action == "list_apis":
-            with _admin_lock:
-                apis = list(_custom_apis)
-            txt = "Custom APIs:\n" + ("\n".join(f"<code>{_esc(a)}</code>" for a in apis) if apis else "—")
-            await edit(chat_id, message_id, txt, reply_markup=_admin_menu_kb())
-            return
-
-        return
-
-    if not data.startswith("pg|"):
-        return
-
-    try:
-        _, number, page_s = data.split("|", 2)
-        page = int(page_s)
-    except Exception:
-        return
-
-    try:
-        records = await asyncio.wait_for(search_phone(number), timeout=QUERY_TIMEOUT)
-    except Exception:
-        log.exception("callback search failed")
-        await edit(chat_id, message_id, "⚠️ Could not load that page. Try again.")
-        return
-
-    if not records:
-        await edit(chat_id, message_id, "❌ No records found.")
-        return
-
-    kb = pagination_kb(number, page, len(records))
-    await edit(chat_id, message_id, render_page(number, records, page), reply_markup=kb)
-
-
-# ─────────────────────────────────────────────────────────────
-# 10. FastAPI routes
-# ─────────────────────────────────────────────────────────────
-async def webhook_handler(request: Request):
-    if request.headers.get("x-telegram-bot-api-secret-token") != WEBHOOK_SECRET:
-        return JSONResponse({"ok": False}, status_code=403)
-    try:
-        update = await request.json()
-    except Exception:
-        return JSONResponse({"ok": True})
-
-    try:
-        if "message" in update or "edited_message" in update:
-            await handle_message(update)
-        elif "callback_query" in update:
-            await handle_callback(update)
-    except Exception:
-        log.exception("Handler error")
-
-    return JSONResponse({"ok": True})
-
-
-async def health_handler(request: Request):
-    return JSONResponse({"status": "ok", "time": time.time()})
-
-
-# ─────────────────────────────────────────────────────────────
-# 11. Gradio UI (ZeroGPU registration)
-# ─────────────────────────────────────────────────────────────
-@spaces.GPU(duration=10)
-def _zerogpu_register():
-    return "gpu-ready"
-
-
-with gr.Blocks(title="Phone Lookup Bot") as demo:
-    gr.Markdown("## Phone Lookup Bot\nTelegram webhook endpoint is live.")
-    _btn = gr.Button("init-gpu", visible=False)
-    _btn.click(fn=_zerogpu_register, inputs=None, outputs=None)
-
-
-# ─────────────────────────────────────────────────────────────
-# 12. Launch + inject routes
-# ─────────────────────────────────────────────────────────────
-demo.launch(
-    server_name="0.0.0.0",
-    server_port=7860,
-    share=False,
-    ssr_mode=False,
-    prevent_thread_lock=True,
-)
-
-live_app = demo.app
-live_app.router.routes.insert(0, StarletteRoute("/webhook", webhook_handler, methods=["POST"]))
-live_app.router.routes.insert(0, StarletteRoute("/health", health_handler, methods=["GET"]))
-live_app.build_middleware_stack()
-
-
-# ─────────────────────────────────────────────────────────────
-# 13. setWebhook (sync — own thread)
-# ─────────────────────────────────────────────────────────────
-def _set_webhook_sync():
-    time.sleep(3)
-    try:
-        with httpx.Client(timeout=15.0) as c:
-            r = c.post(f"{TG_API}/setWebhook", json={
-                "url": f"{SPACE_URL}/webhook",
-                "secret_token": WEBHOOK_SECRET,
-                "allowed_updates": ["message", "edited_message", "callback_query"],
-            })
-            log.info("setWebhook → %s", r.text)
-    except Exception:
-        log.exception("setWebhook failed")
-
-
-threading.Thread(target=_set_webhook_sync, daemon=True).start()
-
-demo.block_thread()