Duplicate from Kzr0xx/icrm-hitek-full-db-mixed

Co-authored-by: Kzr0x <Kzr0xx@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,77 @@
+---
+license: mit
+---
+
+# ICMR + HITEK Full DB (Mixed) — Prebuilt Indexes + One-Click Setup
+
+Prebuilt sorted indexes for the [Kzr0xx/Icmr-and-hitek](https://huggingface.co/datasets/Kzr0xx/Icmr-and-hitek) dataset (2.5B rows, 11 columns, ~104 GB raw parquet).
+
+Building these indexes took **~17 hours** of compute. This repo saves you that work: download + run = API live in ~1-2 hours (download speed dependent).
+
+## Contents
+
+The indexes are stored as **sorted parts** (each < 50 GB, split at row-group boundaries, order preserved) because HuggingFace's classic HTTP upload path caps files at 50 GB. The API reads all parts of an index with one glob — zone-map pruning still makes lookups milliseconds-fast.
+
+| Files | Total | What |
+|---|---|---|
+| `idx_phone.0.parquet` … `idx_phone.6.parquet` | ~102 GB | Data sorted by phoneNumber → phone lookups ~1s |
+| `idx_aadhar.0.parquet` … `idx_aadhar.6.parquet` | ~100 GB | Data sorted by aadharNumber → aadhar lookups ~2s |
+| `main.py` | — | FastAPI app (DuckDB-backed, 15-way parallel, dedup max 2) |
+| `build_index.py` | — | Rebuild indexes from raw parquet (only if you ever need to) |
+| `split_idx.py` | — | Split a built index into < 50 GB parts |
+| `setup.bat` | — | One-click restore (Windows) |
+| `setup.ps1` | — | One-click restore (PowerShell) |
+| `setup.sh` | — | One-click restore (Linux / VPS) |
+
+Raw data files (`part1.parquet`, `part2a.parquet`, `part2b_new.parquet`, 104 GB) live in the **Icmr-and-hitek** repo — the setup scripts download them from there automatically.
+
+## One-click restore
+
+Pick your platform, run ONE file. It downloads data + indexes + code, creates a venv, installs deps, starts the API.
+
+**Windows:** double-click `setup.bat`
+**PowerShell:** right-click → Run with PowerShell, or `powershell -ExecutionPolicy Bypass -File setup.ps1`
+**Linux/VPS:**
+```bash
+chmod +x setup.sh
+./setup.sh
+```
+
+Total download: ~305 GB (104 GB data + ~200 GB index parts). Scripts resume interrupted downloads (`curl -C -`), so a dropped connection is not a problem — just re-run.
+
+## API
+
+Base: `http://127.0.0.1:8001` (Linux: `0.0.0.0:8001`)
+
+| Endpoint | Use |
+|---|---|
+| `GET /search?q=<phone>` | Phone search — **~1s** (indexed) |
+| `GET /search?q=<aadhar>` | Aadhar search — **~2s** (indexed) |
+| `GET /search?q=<name>&limit=10` | Name/text search (falls back to raw scan, slower) |
+| `GET /search?q=X&field=district&mode=exact` | Single-field search |
+| `POST /search/parallel` | Batch: up to 50 searches in parallel |
+| `GET /health` | Status incl. which indexes are active |
+| `GET /docs` | Interactive Swagger UI |
+
+All 11 columns searchable: name, fathersName, phoneNumber, aadharNumber, otherNumber, address, district, pincode, state, town, source. Duplicates capped at 2 per person. `source` = `icmr` | `inddata` (hitek data is labelled inddata).
+
+## Manual start (if scripts already ran)
+
+```bash
+# Windows
+cd /d "C:\path\to\folder"
+start "" .venv\Scripts\python.exe -m uvicorn main:app --host 127.0.0.1 --port 8001
+
+# Linux
+cd /path/to/folder
+ICMR_DATA_DIR="$PWD/data" nohup .venv/bin/python -m uvicorn main:app --host 0.0.0.0 --port 8001 > api.log 2>&1 &
+```
+
+`ICMR_DATA_DIR` points at the `data/` folder; if it is not set, `data/` next to `main.py` is used. `main.py` auto-detects index parts (`idx_phone.*.parquet`) — no config needed.
+
+## Rebuilding indexes (rarely needed)
+
+```bash
+ICMR_DATA_DIR="$PWD/data" .venv/bin/python build_index.py
+```
+Each index takes 6-11 hours on a typical machine. After building, `split_idx.py` can split them into upload-sized parts again.

build_index.py

@@ -0,0 +1,39 @@
+"""Build sorted parquet index copies so DuckDB zone-map pruning makes lookups fast.
+
+Unsorted 104GB parquet forces a full scan (~90s) per query. A copy sorted by the
+search key lets DuckDB skip all but the matching row groups (ms-level lookups).
+
+Creates (skips files that already exist -> resumable):
+  idx_phone.parquet  - sorted by phoneNumber
+  idx_aadhar.parquet - sorted by aadharNumber
+  idx_name.parquet   - sorted by name
+"""
+import duckdb
+import os
+import time
+
+FILES = ["part1.parquet", "part2a.parquet", "part2b_new.parquet"]
+FILES_SQL = ", ".join(f"'{f}'" for f in FILES)
+
+def build(con, field: str, out: str):
+    if os.path.exists(out) and os.path.getsize(out) > 0:
+        print(f"{out} already exists, skipping", flush=True)
+        return
+    print(f"START {out} (sort by {field})", flush=True)
+    t = time.time()
+    con.execute(f"""
+        COPY (SELECT * FROM people ORDER BY {field} NULLS LAST)
+        TO '{out}' (FORMAT PARQUET, COMPRESSION ZSTD)
+    """)
+    print(f"DONE {out} in {time.time()-t:.1f}s", flush=True)
+
+con = duckdb.connect()
+con.execute("INSTALL parquet; LOAD parquet;")
+con.execute("SET threads = 12")
+con.execute("SET memory_limit = '27GB'")
+con.execute(f"CREATE VIEW people AS SELECT * FROM read_parquet([{FILES_SQL}])")
+
+build(con, "phoneNumber", "idx_phone.parquet")
+build(con, "aadharNumber", "idx_aadhar.parquet")
+build(con, "name", "idx_name.parquet")
+print("ALL DONE", flush=True)

idx_aadhar.0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d30e32b5884fa366e8283ceca08fe97e4ce11783098439a86f30742af870e85
+size 16856203726

idx_aadhar.1.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23ae9c6458c9dc92608f68e5cf1034d7f889ec820f50638c6425604fbc3af0f7
+size 15716468686

idx_aadhar.2.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb3a2aed1f01958a6817d471900c8573a8480ef0ed8a4839043a7d2087dedd72
+size 15701861469

idx_aadhar.3.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:262dd17d014c2d191e77321f98f264f295a2ca25ea6c3d32e18817828926c95e
+size 15702907795

idx_aadhar.4.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff2b70012c8eda1394e5cc77ed85621245433ec88e59ef8f8adb5aada99eac89
+size 21250330138

idx_aadhar.5.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc76e2a67857e7cd9e8c24c7a803a5d8e67c659f85ef1aa968b27032d7729bfa
+size 26123380421

idx_aadhar.6.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d047df27b2b91e2f61e25392ab2e3fb0f97d3523c9411d1a9f119b122a39cf01
+size 11730300913

idx_phone.0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c308a3bd32384546a3a64ad766a50003ff62d7a52d34537c5d0a05bff0b9b6e5
+size 17050842079

idx_phone.1.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae1a39a2fecb5484fda3ab8fb861caf506c021986827734b2c4183f3c4b39f48
+size 16672917498

idx_phone.2.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1bfe865a0e40475b12bf1d275d5dbad556426064d36f1b2d7a1f2ab04d7d6d4
+size 16592087348

idx_phone.3.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e22b118321237ec583f2f4de3f956fb66a68a2f92af1ebea6418489412d322c
+size 17107452500

idx_phone.4.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6eaddca4bb538638243415c131531d6b9dd318cb9860265111f4ea8929c3b38e
+size 16886880219

idx_phone.5.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34f8083b4daffb93af1f9a79290592b981589514bc96660ffb7115e27e6c7971
+size 16489637305

idx_phone.6.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2df73634c0ad9561691f8e5e988c2901b180a1119505a72e7349ea6a68e2320a
+size 3210381696

main.py

@@ -0,0 +1,314 @@
+"""FastAPI backend over DuckDB - ICMR + HITEK combined dataset (2.5B rows, 11 cols).
+
+Index-aware routing:
+  - idx_phone.parquet  (sorted by phoneNumber)  -> fast exact phone/other lookups
+  - idx_aadhar.parquet (sorted by aadharNumber) -> fast exact aadhar lookups
+  - idx_name.parquet   (sorted by name)         -> fast name prefix/exact
+  - Falls back to full scans of raw parquet while indexes are still building.
+Dedup: max 2 rows per person. source column included (icmr / inddata "connected docs").
+"""
+import asyncio
+import glob
+import json
+import os
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any
+
+import duckdb
+from fastapi import FastAPI, HTTPException, Query, Response
+from pydantic import BaseModel
+
+BASE = os.path.dirname(os.path.abspath(__file__))
+# data files may live in BASE or BASE/data (setup scripts download into data/)
+_DATA_DIR = os.environ.get("ICMR_DATA_DIR") or \
+    (os.path.join(BASE, "data") if os.path.isdir(os.path.join(BASE, "data")) else BASE)
+PARQUET_FILES = [os.path.join(_DATA_DIR, f) for f in
+                 ["part1.parquet", "part2a.parquet", "part2b_new.parquet"]]
+IDX_PHONE = os.path.join(_DATA_DIR, "idx_phone.parquet")
+IDX_AADHAR = os.path.join(_DATA_DIR, "idx_aadhar.parquet")
+IDX_NAME = os.path.join(_DATA_DIR, "idx_name.parquet")
+PARALLELISM = int(os.environ.get("ICMR_PARALLEL", "15"))
+THREADS_PER_CONN = int(os.environ.get("ICMR_THREADS_PER_CONN", "8"))
+DUPLICATE_CAP = 2  # max 2 copies of the same person in results
+
+SEARCH_FIELDS = [
+    "name", "fathersName", "phoneNumber", "aadharNumber", "otherNumber",
+    "address", "district", "pincode", "state", "town", "source",
+]
+NUMBER_FIELDS = ["phoneNumber", "aadharNumber", "otherNumber"]
+
+app = FastAPI(title="ICMR + HITEK Search API",
+              description="DuckDB-backed search over 2.5B records (11 cols, dedup max 2)")
+
+# ---- DuckDB connection pool (one connection per worker thread) ----
+_conns: list[duckdb.DuckDBPyConnection] = []
+_conns_lock = threading.Lock()
+_thread_local = threading.local()
+pool = ThreadPoolExecutor(max_workers=PARALLELISM, thread_name_prefix="duck")
+
+_MISSING = [f for f in PARQUET_FILES if not os.path.exists(f)]
+
+
+def _idx_files(path: str) -> list[str]:
+    """Index may be a single file or split into sorted parts (idx_phone.0.parquet...)."""
+    base, ext = os.path.splitext(path)  # idx_phone.parquet -> idx_phone / .parquet
+    parts = sorted(glob.glob(f"{base}.*{ext}"))
+    if parts and all(os.path.getsize(p) > 0 for p in parts):
+        return parts
+    return [path] if os.path.exists(path) and os.path.getsize(path) > 0 else []
+
+
+def _idx_ready(path: str) -> bool:
+    # index is usable when: file(s) exist+non-empty AND not caught mid-build
+    # (build writes in place, so a START without DONE in the log = partial file)
+    if not _idx_files(path):
+        return False
+    try:
+        with open(os.path.join(BASE, "build_index.log"), encoding="utf-8",
+                  errors="ignore") as f:
+            log = f.read()
+    except OSError:
+        log = ""  # no log (fresh download) -> trust the downloaded file
+    name = os.path.basename(path)
+    if f"DONE {name}" in log:
+        return True
+    if f"START {name}" in log:
+        return False  # build in progress / was interrupted -> partial
+    return True  # no build ever started here -> file was downloaded whole
+
+
+def _new_conn() -> duckdb.DuckDBPyConnection:
+    con = duckdb.connect()  # in-memory
+    con.execute("INSTALL parquet; LOAD parquet;")
+    files = ", ".join(f"'{f}'" for f in PARQUET_FILES if os.path.exists(f))
+    con.execute(f"CREATE VIEW people AS SELECT * FROM read_parquet([{files}])")
+    # sorted index views (only if built) - zone-map pruning makes lookups fast
+    for idx_path, view in [(IDX_PHONE, "people_phone"),
+                           (IDX_AADHAR, "people_aadhar"),
+                           (IDX_NAME, "people_name")]:
+        files = _idx_files(idx_path)
+        if files and _idx_ready(idx_path):
+            lst = ", ".join(f"'{f}'" for f in files)
+            con.execute(f"CREATE VIEW {view} AS SELECT * FROM read_parquet([{lst}])")
+    con.execute(f"SET threads = {THREADS_PER_CONN}")
+    return con
+
+
+def _thread_id() -> int:
+    tid = getattr(_thread_local, "id", None)
+    if tid is None:
+        with _conns_lock:
+            tid = len(_conns)
+            _thread_local.id = tid
+    return tid
+
+
+def _get_conn() -> duckdb.DuckDBPyConnection:
+    ident = _thread_id()
+    with _conns_lock:
+        while len(_conns) <= ident:
+            _conns.append(_new_conn())
+    return _conns[ident]
+
+
+# ---- Dedup: max 2 copies per person ----
+def _person_key(row: dict[str, Any]) -> tuple[str, ...]:
+    ph = (row.get("phoneNumber") or "").strip()
+    ad = (row.get("aadharNumber") or "").strip()
+    if ph or ad:
+        return (ph, ad)
+    return (row.get("name") or "").strip(), (row.get("fathersName") or "").strip()
+
+
+def _cap_duplicates(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Keep at most DUPLICATE_CAP rows per person (same phone+aadhar identity)."""
+    seen: dict[tuple[str, ...], int] = {}
+    out: list[dict[str, Any]] = []
+    for r in rows:
+        k = _person_key(r)
+        n = seen.get(k, 0)
+        if n < DUPLICATE_CAP:
+            seen[k] = n + 1
+            out.append(r)
+    return out
+
+
+# ---- Query helpers ----
+def _run_sql(sql: str) -> list[dict[str, Any]]:
+    con = _get_conn()
+    rows = con.execute(sql).fetchall()
+    cols = [d[0] for d in con.description]
+    return [dict(zip(cols, r)) for r in rows]
+
+
+def _source_clause(source: str | None) -> str:
+    if source and source in ("icmr", "hitek", "inddata"):
+        src = "hitek" if source == "hitek" else source
+        return f" AND source = '{src}'"
+    return ""
+
+
+def _exact_scan(field: str, value: str, limit: int, source: str | None = None) -> str:
+    v = value.replace("'", "''")
+    return (f"SELECT * FROM people WHERE {field} = '{v}'"
+            f"{_source_clause(source)} LIMIT {limit * DUPLICATE_CAP + 20}")
+
+
+def _run_field_search(field: str, value: str, mode: str, limit: int,
+                      source: str | None = None) -> dict[str, Any]:
+    if field not in SEARCH_FIELDS:
+        raise ValueError(f"Unknown field: {field}")
+    v = value.replace("'", "''")
+    view = "people"
+    # use sorted index view when available for the hot fields
+    if mode == "exact":
+        if field == "phoneNumber" and _idx_ready(IDX_PHONE):
+            view = "people_phone"
+        elif field == "aadharNumber" and _idx_ready(IDX_AADHAR):
+            view = "people_aadhar"
+        elif field == "name" and _idx_ready(IDX_NAME):
+            view = "people_name"
+        sql = (f"SELECT * FROM {view} WHERE {field} = '{v}'"
+               f"{_source_clause(source)} LIMIT {limit * DUPLICATE_CAP + 20}")
+    elif mode == "contains":
+        if field == "name" and _idx_ready(IDX_NAME):
+            view = "people_name"  # sorted helps prefix; contains still scans but cached
+        v2 = v.replace("%", r"\%").replace("_", r"\_")
+        sql = (f"SELECT * FROM {view} WHERE {field} ILIKE '%{v2}%' ESCAPE '\\'"
+               f"{_source_clause(source)} LIMIT {limit * DUPLICATE_CAP + 20}")
+    else:
+        raise ValueError(f"Unknown mode: {mode}")
+    con = _get_conn()
+    rows = con.execute(sql).fetchall()
+    cols = [d[0] for d in con.description]
+    results = _cap_duplicates([dict(zip(cols, r)) for r in rows])[:limit]
+    return {"field": field, "value": value, "mode": mode, "count": len(results),
+            "results": results}
+
+
+async def _parallel(queries: list[tuple[str, str, str, int]]) -> list[dict[str, Any]]:
+    loop = asyncio.get_running_loop()
+
+    async def one(t: tuple[str, str, str, int]) -> dict[str, Any]:
+        field, value, mode, limit = t
+        return await loop.run_in_executor(pool, _run_field_search, field, value, mode, limit)
+
+    return await asyncio.gather(*[one(t) for t in queries])
+
+
+async def _unified_search(q: str, limit: int, source: str | None = None) -> dict[str, Any]:
+    """Smart unified search: uses sorted indexes per field, merges, dedups."""
+    q = q.strip()
+    is_num = q.isdigit() and len(q) >= 8
+    loop = asyncio.get_running_loop()
+
+    if is_num:
+        # number-like -> exact match, phone index first (fast), then aadhar, then other
+        all_rows: list[dict[str, Any]] = []
+        searched: list[str] = []
+        # phone index ready -> instant; else full scan (slow, skip if we already found hits)
+        if _idx_ready(IDX_PHONE):
+            r = await loop.run_in_executor(pool, _run_field_search, "phoneNumber", q,
+                                           "exact", limit, source)
+            all_rows.extend(r["results"])
+            searched.append("phoneNumber")
+        if not all_rows and _idx_ready(IDX_AADHAR):
+            r = await loop.run_in_executor(pool, _run_field_search, "aadharNumber", q,
+                                           "exact", limit, source)
+            all_rows.extend(r["results"])
+            searched.append("aadharNumber")
+        if not all_rows and _idx_ready(IDX_NAME):
+            r = await loop.run_in_executor(pool, _run_field_search, "otherNumber", q,
+                                           "exact", limit, source)
+            all_rows.extend(r["results"])
+            searched.append("otherNumber")
+        all_rows = _cap_duplicates(all_rows)[:limit]
+        return {"query": q, "searched_fields": searched or list(NUMBER_FIELDS),
+                "dedup": DUPLICATE_CAP, "count": len(all_rows), "results": all_rows}
+    else:
+        # text -> name + fathersName contains via name index, then address/district/etc.
+        jobs = [loop.run_in_executor(pool, _run_field_search, "name", q, "contains",
+                                     limit, source)]
+        if _idx_ready(IDX_NAME):
+            jobs.append(loop.run_in_executor(pool, _run_field_search, "fathersName", q,
+                                             "contains", limit, source))
+        # also check number fields exact (safety net, only if numbers typed)
+        results = await asyncio.gather(*jobs)
+        all_rows = []
+        for r in results:
+            all_rows.extend(r["results"])
+        all_rows = _cap_duplicates(all_rows)[:limit]
+        fields = ["name", "fathersName"] + NUMBER_FIELDS
+        return {"query": q, "searched_fields": fields, "dedup": DUPLICATE_CAP,
+                "count": len(all_rows), "results": all_rows}
+
+
+def _pretty(data: dict[str, Any], pretty: bool) -> Response:
+    if pretty:
+        return Response(content=json.dumps(data, indent=2, ensure_ascii=False),
+                        media_type="application/json")
+    return Response(content=json.dumps(data, ensure_ascii=False),
+                    media_type="application/json")
+
+
+# ---- API ----
+class BatchRequest(BaseModel):
+    queries: list[dict[str, Any]]
+    limit: int = 10
+
+
+@app.get("/")
+def root():
+    return {"app": "ICMR + HITEK Search API", "records": 2_504_793_870,
+            "files": [os.path.basename(f) for f in PARQUET_FILES],
+            "indexes": {"phone": _idx_ready(IDX_PHONE), "aadhar": _idx_ready(IDX_AADHAR),
+                        "name": _idx_ready(IDX_NAME)},
+            "columns": SEARCH_FIELDS, "parallelism": PARALLELISM, "dedup": DUPLICATE_CAP,
+            "docs": "/docs"}
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "files_ready": len(PARQUET_FILES) - len(_MISSING),
+            "files_total": len(PARQUET_FILES),
+            "indexes": {"phone": _idx_ready(IDX_PHONE), "aadhar": _idx_ready(IDX_AADHAR),
+                        "name": _idx_ready(IDX_NAME)},
+            "missing": [os.path.basename(f) for f in _MISSING]}
+
+
+@app.get("/search")
+async def search(
+    q: str = Query(..., description="Search term - matches name, phone, aadhar, other, address, district, pincode, state, town"),
+    field: str | None = Query(None, description=f"Restrict to one field: {SEARCH_FIELDS}"),
+    mode: str = Query("contains", pattern="^(exact|contains)$"),
+    limit: int = Query(10, ge=1, le=1000),
+    source: str | None = Query(None, pattern="^(icmr|hitek|inddata)$",
+                               description="Filter by source: icmr, hitek (=inddata), inddata"),
+    pretty: bool = Query(True, description="Pretty-print JSON"),
+):
+    """Unified search across all 11 columns. Duplicates capped at 2 per person."""
+    if field:
+        try:
+            data = _run_field_search(field, q, mode, limit, source)
+        except ValueError as e:
+            raise HTTPException(400, str(e))
+        data = {"query": q, "field": field, "mode": mode, "dedup": DUPLICATE_CAP,
+                "count": data["count"], "results": data["results"]}
+    else:
+        data = await _unified_search(q, limit, source)
+    return _pretty(data, pretty)
+
+
+@app.post("/search/parallel")
+async def search_parallel(req: BatchRequest):
+    """Run up to 50 searches in parallel across a pool of DuckDB connections."""
+    if not req.queries:
+        raise HTTPException(400, "queries must not be empty")
+    if len(req.queries) > 50:
+        raise HTTPException(400, "max 50 queries per batch")
+    results = await _parallel([(item.get("field", "name"), item.get("value", ""),
+                                item.get("mode", "contains"), int(item.get("limit", req.limit)))
+                               for item in req.queries])
+    out = [{"error": str(r)} if isinstance(r, Exception) else r for r in results]
+    return _pretty({"searches": len(req.queries), "parallelism": PARALLELISM, "results": out}, True)

requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.110
+uvicorn>=0.29
+duckdb>=1.0
+pydantic>=2.0

run_api.bat

@@ -0,0 +1,4 @@
+@echo off
+cd /d "%~dp0"
+start "ICMR+HITEK API" /min "C:\Users\Administrator\Desktop\icmr\.venv\Scripts\python.exe" -m uvicorn main:app --host 127.0.0.1 --port 8001 --workers 1 > api.log 2>&1
+echo API starting on http://127.0.0.1:8001 ... log: api.log

setup.bat

@@ -0,0 +1,71 @@
+@echo off
+setlocal enabledelayedexpansion
+chcp 65001 >nul
+title ICMR+HITEK API - One-Click Setup
+echo ============================================================
+echo  ICMR + HITEK Search API - One-Click Setup (Windows)
+echo  Total download: ~305 GB. Make sure you have enough space!
+echo ============================================================
+echo.
+
+set "DATA_REPO=Kzr0xx/Icmr-and-hitek"
+set "FULL_REPO=Kzr0xx/icrm-hitek-full-db-mixed"
+set "FILES=part1.parquet part2a.parquet part2b_new.parquet"
+set "IDX=idx_phone.0.parquet idx_phone.1.parquet idx_phone.2.parquet idx_phone.3.parquet idx_phone.4.parquet idx_phone.5.parquet idx_phone.6.parquet idx_aadhar.0.parquet idx_aadhar.1.parquet idx_aadhar.2.parquet idx_aadhar.3.parquet idx_aadhar.4.parquet idx_aadhar.5.parquet idx_aadhar.6.parquet"
+set "CODE=main.py build_index.py run_api.bat requirements.txt"
+
+if not exist "%~dp0data" mkdir "%~dp0data"
+cd /d "%~dp0"
+
+echo [1/5] Downloading data files (104 GB)...
+for %%f in (%FILES%) do (
+    if not exist "data\%%f" (
+        echo   Downloading %%f ...
+        curl -L -C - -o "data\%%f" "https://huggingface.co/datasets/%DATA_REPO%/resolve/main/%%f"
+        if errorlevel 1 ( echo   FAILED: %%f & pause & exit /b 1 )
+    ) else (
+        echo   %%f already exists, skipping
+    )
+)
+
+echo [2/5] Downloading index parts (200 GB)...
+for %%f in (%IDX%) do (
+    if not exist "data\%%f" (
+        echo   Downloading %%f ...
+        curl -L -C - -o "data\%%f" "https://huggingface.co/datasets/%FULL_REPO%/resolve/main/%%f"
+        if errorlevel 1 ( echo   FAILED: %%f & pause & exit /b 1 )
+    ) else (
+        echo   %%f already exists, skipping
+    )
+)
+
+echo [3/5] Downloading code files...
+for %%f in (%CODE%) do (
+    curl -L -C - -o "%%f" "https://huggingface.co/datasets/%FULL_REPO%/resolve/main/%%f"
+)
+
+echo [4/5] Setting up Python environment...
+set "PYCMD=python"
+where python >nul 2>nul
+if errorlevel 1 (
+    where py >nul 2>nul
+    if errorlevel 1 (
+        echo   Python not found! Install Python 3.11+ from https://www.python.org/downloads/
+        pause & exit /b 1
+    )
+    set "PYCMD=py -3"
+)
+if not exist ".venv" %PYCMD% -m venv .venv
+".venv\Scripts\python.exe" -m pip install -q --upgrade pip
+".venv\Scripts\python.exe" -m pip install -q -r requirements.txt
+
+echo [5/5] Starting API server...
+set "ICMR_DATA_DIR=%~dp0data"
+start "ICMR+HITEK API" /min ".venv\Scripts\python.exe" -m uvicorn main:app --host 127.0.0.1 --port 8001 --workers 1
+echo.
+echo ============================================================
+echo  API is starting on http://127.0.0.1:8001
+echo  Docs: http://127.0.0.1:8001/docs
+echo ============================================================
+timeout /t 5 >nul
+pause

setup.ps1

@@ -0,0 +1,62 @@
+# ICMR + HITEK Search API - One-Click Setup (PowerShell)
+# Total download: ~305 GB. Make sure you have enough space!
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+
+$DataRepo  = "Kzr0xx/Icmr-and-hitek"
+$FullRepo  = "Kzr0xx/icrm-hitek-full-db-mixed"
+$Files     = @("part1.parquet", "part2a.parquet", "part2b_new.parquet")
+$Idx       = @("idx_phone.0.parquet", "idx_phone.1.parquet", "idx_phone.2.parquet", "idx_phone.3.parquet", "idx_phone.4.parquet", "idx_phone.5.parquet", "idx_phone.6.parquet", "idx_aadhar.0.parquet", "idx_aadhar.1.parquet", "idx_aadhar.2.parquet", "idx_aadhar.3.parquet", "idx_aadhar.4.parquet", "idx_aadhar.5.parquet", "idx_aadhar.6.parquet")
+$Code      = @("main.py", "build_index.py", "run_api.bat", "requirements.txt")
+
+$Root = Split-Path -Parent $MyInvocation.MyCommand.Path
+Set-Location $Root
+$DataDir = Join-Path $Root "data"
+New-Item -ItemType Directory -Force -Path $DataDir | Out-Null
+
+function Download-File($Name, $Repo, $Dest) {
+    if (Test-Path $Dest) { Write-Host "  $Name already exists, skipping"; return }
+    Write-Host "  Downloading $Name ..."
+    $url = "https://huggingface.co/datasets/$Repo/resolve/main/$Name"
+    # curl.exe is bundled with Windows 10+ and supports resume (-C -)
+    & curl.exe -L -C - -o $Dest $url
+    if ($LASTEXITCODE -ne 0) { throw "FAILED: $Name" }
+}
+
+Write-Host "============================================================"
+Write-Host " ICMR + HITEK Search API - One-Click Setup (PowerShell)"
+Write-Host "============================================================"
+Write-Host ""
+
+Write-Host "[1/5] Downloading data files (104 GB)..."
+foreach ($f in $Files) { Download-File $f $DataRepo (Join-Path $DataDir $f) }
+
+Write-Host "[2/5] Downloading index parts (200 GB)..."
+foreach ($f in $Idx) { Download-File $f $FullRepo (Join-Path $DataDir $f) }
+
+Write-Host "[3/5] Downloading code files..."
+foreach ($f in $Code) {
+    curl.exe -L -C - -o $f "https://huggingface.co/datasets/$FullRepo/resolve/main/$f"
+}
+
+Write-Host "[4/5] Setting up Python environment..."
+$py = Get-Command python -ErrorAction SilentlyContinue
+if (-not $py) {
+    $py = Get-Command py -ErrorAction SilentlyContinue
+    if (-not $py) { throw "Python not found! Install Python 3.11+ from https://www.python.org/downloads/" }
+    & py -3 -m venv .venv
+} else {
+    if (-not (Test-Path ".venv")) { python -m venv .venv }
+}
+& ".venv\Scripts\python.exe" -m pip install -q --upgrade pip
+& ".venv\Scripts\python.exe" -m pip install -q -r requirements.txt
+
+Write-Host "[5/5] Starting API server..."
+$env:ICMR_DATA_DIR = $DataDir
+Start-Process -FilePath ".venv\Scripts\python.exe" -ArgumentList "-m","uvicorn","main:app","--host","127.0.0.1","--port","8001","--workers","1" -WorkingDirectory $Root -WindowStyle Minimized
+
+Write-Host ""
+Write-Host "============================================================"
+Write-Host " API is starting on http://127.0.0.1:8001"
+Write-Host " Docs: http://127.0.0.1:8001/docs"
+Write-Host "============================================================"

setup.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# ICMR + HITEK Search API - One-Click Setup (Linux / VPS)
+# Total download: ~305 GB. Make sure you have enough space!
+set -euo pipefail
+
+DATA_REPO="Kzr0xx/Icmr-and-hitek"
+FULL_REPO="Kzr0xx/icrm-hitek-full-db-mixed"
+FILES=("part1.parquet" "part2a.parquet" "part2b_new.parquet")
+IDX=("idx_phone.0.parquet" "idx_phone.1.parquet" "idx_phone.2.parquet" "idx_phone.3.parquet" "idx_phone.4.parquet" "idx_phone.5.parquet" "idx_phone.6.parquet" "idx_aadhar.0.parquet" "idx_aadhar.1.parquet" "idx_aadhar.2.parquet" "idx_aadhar.3.parquet" "idx_aadhar.4.parquet" "idx_aadhar.5.parquet" "idx_aadhar.6.parquet")
+CODE=("main.py" "build_index.py" "run_api.bat" "requirements.txt")
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$ROOT"
+mkdir -p data
+
+dl() { # dl <name> <repo> <dest>
+    local name="$1" repo="$2" dest="$3"
+    if [ -f "$dest" ]; then
+        echo "  $name already exists, skipping"
+        return
+    fi
+    echo "  Downloading $name ..."
+    curl -L -C - -o "$dest" "https://huggingface.co/datasets/$repo/resolve/main/$name"
+}
+
+echo "============================================================"
+echo " ICMR + HITEK Search API - One-Click Setup (Linux/VPS)"
+echo "============================================================"
+echo ""
+
+echo "[1/5] Downloading data files (104 GB)..."
+for f in "${FILES[@]}"; do dl "$f" "$DATA_REPO" "data/$f"; done
+
+echo "[2/5] Downloading index parts (200 GB)..."
+for f in "${IDX[@]}"; do dl "$f" "$FULL_REPO" "data/$f"; done
+
+echo "[3/5] Downloading code files..."
+for f in "${CODE[@]}"; do
+    curl -L -C - -o "$f" "https://huggingface.co/datasets/$FULL_REPO/resolve/main/$f"
+done
+
+echo "[4/5] Setting up Python environment..."
+if ! command -v python3 >/dev/null 2>&1; then
+    echo "  Installing python3..."
+    sudo apt-get update -y && sudo apt-get install -y python3 python3-venv python3-pip
+fi
+if [ ! -d ".venv" ]; then python3 -m venv .venv; fi
+".venv/bin/python" -m pip install -q --upgrade pip
+".venv/bin/python" -m pip install -q -r requirements.txt
+
+echo "[5/5] Starting API server (background, nohup)..."
+export ICMR_DATA_DIR="$ROOT/data"
+nohup ".venv/bin/python" -m uvicorn main:app --host 0.0.0.0 --port 8001 --workers 1 \
+    > api.log 2>&1 &
+
+echo ""
+echo "============================================================"
+echo " API starting on http://0.0.0.0:8001"
+echo " Docs: http://<server-ip>:8001/docs"
+echo " Log: api.log"
+echo "============================================================"
+sleep 5
+curl -s http://127.0.0.1:8001/health && echo ""
+echo "Done!"

split_idx.py

@@ -0,0 +1,100 @@
+"""Parallel split of sorted index parquets into parts < 50 GB for HTTP upload to HF.
+
+Windows Xet upload stalls on large files; the HTTP fallback caps at 50 GB/file.
+Parts preserve sorted order (contiguous row-group ranges), so DuckDB zone-map
+pruning still works across parts. Multiprocessing (N_WORKERS) since pyarrow's
+writer is mostly single-threaded. Resumable: existing completed parts are skipped.
+"""
+import multiprocessing as mp
+import os
+import time
+
+import pyarrow.parquet as pq
+
+BASE = os.path.dirname(os.path.abspath(__file__))
+# budget on UNCOMPRESSED size; SNAPPY output lands well under the 50 GB cap
+TARGET_UNCOMPRESSED = 45 * 1024**3
+N_WORKERS = 5
+BATCH_GROUPS = 100  # row groups read per batch (~1-3 GiB in RAM)
+
+JOBS = ["idx_phone.parquet", "idx_aadhar.parquet"]
+
+
+def plan_partitions(sizes, target):
+    """Split row-group size list into (start, end) buckets each ~target bytes."""
+    parts = []
+    acc = 0
+    start = 0
+    for i, s in enumerate(sizes):
+        acc += s
+        if acc >= target and i - start > 200:  # at least 200 row groups per part
+            parts.append((start, i + 1))
+            start = i + 1
+            acc = 0
+    if start < len(sizes):
+        parts.append((start, len(sizes)))
+    return parts
+
+
+def split_one(src, pi, a, b):
+    out = f"{os.path.splitext(src)[0]}.{pi}.parquet"
+    if os.path.exists(out) and os.path.getsize(out) > 0:
+        print(f"  {out} exists, skip", flush=True)
+        return
+    tmp = out + ".tmp"
+    if os.path.exists(tmp):
+        os.remove(tmp)
+    t0 = time.time()
+    pf = pq.ParquetFile(src)
+    with pq.ParquetWriter(tmp, pf.schema_arrow, compression="snappy",
+                          use_dictionary=True, data_page_version="2.0",
+                          version="2.6") as w:
+        g = a
+        while g < b:
+            g2 = min(g + BATCH_GROUPS, b)
+            w.write_table(pf.read_row_groups(list(range(g, g2))))
+            g = g2
+    os.rename(tmp, out)
+    print(f"  DONE {out} ({os.path.getsize(out)/1073741824:.1f} GiB) "
+          f"in {time.time()-t0:.0f}s", flush=True)
+
+
+def worker(wid, tasklist):
+    for src, pi, a, b in tasklist:
+        print(f"[w{wid}] start {src} part {pi} (groups {a}-{b})", flush=True)
+        try:
+            split_one(src, pi, a, b)
+        except Exception as e:
+            print(f"[w{wid}] FAIL {src} part {pi}: {e}", flush=True)
+
+
+def main():
+    jobs = []  # (src, [(a,b), ...])
+    for src in JOBS:
+        if not os.path.exists(src):
+            print(f"SKIP {src}: not found", flush=True)
+            continue
+        pf = pq.ParquetFile(src)
+        sizes = [pf.metadata.row_group(i).total_byte_size
+                 for i in range(pf.num_row_groups)]
+        boundaries = plan_partitions(sizes, TARGET_UNCOMPRESSED)
+        print(f"{src}: {pf.num_row_groups} row groups, "
+              f"{sum(sizes)/1073741824:.1f} GiB uncompressed -> "
+              f"{len(boundaries)} parts", flush=True)
+        jobs.append((src, boundaries))
+
+    flat = [(src, i, a, b)
+            for src, bnd in jobs for i, (a, b) in enumerate(bnd)]
+    procs = []
+    for wi in range(N_WORKERS):
+        mine = flat[wi::N_WORKERS]
+        p = mp.Process(target=worker, args=(wi, mine))
+        p.start()
+        procs.append(p)
+    for p in procs:
+        p.join()
+    print("ALL DONE", flush=True)
+
+
+if __name__ == "__main__":
+    main()

upload_parts.py

@@ -0,0 +1,66 @@
+"""Upload split index parts to HF via the classic HTTP path (Xet disabled).
+
+Windows Xet upload stalls on big files; the HTTP fallback caps at 50 GB/file,
+so the <50 GB parts from split_idx.py are uploaded here. Resumable: parts
+already present on HF are skipped. Watches the folder until all parts done.
+"""
+import glob
+import os
+import sys
+import time
+
+os.environ["HF_HUB_DISABLE_XET"] = "1"
+
+from huggingface_hub import HfApi
+
+BASE = os.path.dirname(os.path.abspath(__file__))
+REPO = "Kzr0xx/icrm-hitek-full-db-mixed"
+
+
+def get_token():
+    t = os.environ.get("HF_TOKEN")
+    if t:
+        return t
+    try:
+        with open(os.path.join(BASE, "hf_token.txt"), encoding="utf-8") as f:
+            t = f.read().strip()
+        if t:
+            return t
+    except OSError:
+        pass
+    sys.exit("HF_TOKEN env var or hf_token.txt required")
+
+
+def main():
+    api = HfApi(token=get_token())
+    while True:
+        parts = sorted(glob.glob(os.path.join(BASE, "idx_*.?.parquet")))
+        pending = []
+        for p in parts:
+            name = os.path.basename(p)
+            try:
+                if api.file_exists(repo_id=REPO, filename=name,
+                                   repo_type="dataset"):
+                    continue
+            except Exception as e:
+                print(f"  check {name}: {e}", flush=True)
+            pending.append(p)
+        if not pending and parts:
+            print("ALL UPLOADED", flush=True)
+            break
+        for p in pending:
+            name = os.path.basename(p)
+            print(f"UPLOAD {name} ({os.path.getsize(p)/1073741824:.1f} GiB)",
+                  flush=True)
+            t0 = time.time()
+            try:
+                api.upload_file(path_or_fileobj=p, path_in_repo=name,
+                                repo_id=REPO, repo_type="dataset")
+                print(f"DONE {name} in {time.time()-t0:.0f}s", flush=True)
+            except Exception as e:
+                print(f"FAIL {name}: {e}", flush=True)
+        time.sleep(30)
+
+
+if __name__ == "__main__":
+    main()