arjuna-ocr 1.2.1__py3-none-any.whl

arjuna_ocr-1.2.1.dist-info/METADATA

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: arjuna-ocr
+Version: 1.2.1
+Summary: Arjuna-OCR [Kn&En]: layout-aware Kannada + English document OCR (ONNX Runtime, optional TensorRT)
+Author: Chethan (anandkaman)
+License: Apache-2.0
+Project-URL: Homepage, https://huggingface.co/anandkaman/arjuna-ocr
+Project-URL: Models, https://huggingface.co/anandkaman/arjuna-ocr
+Project-URL: Releases, https://huggingface.co/anandkaman/arjuna-ocr-kn-en
+Project-URL: Demo, https://huggingface.co/spaces/anandkaman/arjuna_ocr_demo
+Keywords: ocr,kannada,document-ai,layout-analysis,onnx,tensorrt,indic
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: onnxruntime>=1.20
+Requires-Dist: numpy
+Requires-Dist: opencv-python-headless
+Requires-Dist: pyclipper
+Requires-Dist: shapely
+Requires-Dist: pyyaml
+Requires-Dist: regex
+Requires-Dist: onnx
+Requires-Dist: huggingface_hub>=0.23
+Provides-Extra: gpu
+Requires-Dist: onnxruntime-gpu>=1.20; extra == "gpu"
+Provides-Extra: trt
+Requires-Dist: onnxruntime-gpu>=1.20; extra == "trt"
+Requires-Dist: tensorrt>=10.0; extra == "trt"
+Provides-Extra: server
+Requires-Dist: fastapi>=0.110; extra == "server"
+Requires-Dist: uvicorn>=0.29; extra == "server"
+Requires-Dist: python-multipart; extra == "server"
+Provides-Extra: pdf
+Requires-Dist: pypdfium2>=4.0; extra == "pdf"
+Provides-Extra: cpu
+Requires-Dist: onnxruntime>=1.20; extra == "cpu"
+Provides-Extra: all
+Requires-Dist: onnxruntime-gpu>=1.20; extra == "all"
+Requires-Dist: tensorrt>=10.0; extra == "all"
+Requires-Dist: fastapi>=0.110; extra == "all"
+Requires-Dist: uvicorn>=0.29; extra == "all"
+Requires-Dist: python-multipart; extra == "all"
+Requires-Dist: pypdfium2>=4.0; extra == "all"
+Dynamic: license-file
+
+# Arjuna-OCR [Kn&En]
+
+Layout-aware **Kannada + English** document OCR: a layout model, a text detector and a CTC recognizer in ONNX, with
+tables, reading order, per-line confidence and review flags. No language model, no GPU required.
+
+```bash
+pip install arjuna-ocr          # CPU, works anywhere
+
+
+arjuna doctor                   # what this machine can do and what the pipeline will use
+arjuna ocr page.pdf -o out/     # files, folders, globs or PDFs -> JSON / Markdown / hOCR / ALTO / TSV
+arjuna serve --port 8080        # HTTP server
+```
+
+```python
+from kanen_infer import KanEnOCR
+ocr = KanEnOCR()            # detects hardware, configures itself
+doc = ocr.page("page.png")  # kanen-ocr/1.0 JSON
+print(ocr.render(doc, "md"))
+```
+
+The models (~170 MB) download once from [anandkaman/arjuna-ocr](https://huggingface.co/anandkaman/arjuna-ocr) at the
+revision matching this package version, and are cached. Point `ARJUNA_MODELS` at a local copy for air-gapped installs.
+
+**Speed and accuracy.** 12.8 pages/s on an RTX 5060 Ti with TensorRT, ~4.6 on the CUDA provider, seconds per page on CPU.
+On a frozen 40-page private-document set: word F1 0.967, page CER 3.1 %; 96.3 % word accuracy on Mozhi, 93.7 % on MILE.
+TensorRT engines are built in the background on first use — the pipeline serves immediately on CUDA and swaps each engine
+in only after it reproduces the output of the session it replaces.
+
+Full documentation, hosted-inference instructions and the evaluation record: the model repositories linked above.
+**Licences**: code, recognizer and detector Apache-2.0; the layout model is AGPL-3.0 (see its NOTICE).

arjuna_ocr-1.2.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+arjuna_ocr-1.2.1.dist-info/licenses/LICENSE,sha256=kSUONfbMTSXdruS_p0-W_SeqHvGH6dVTgENFs2Od-Is,175
+kanen_infer/__init__.py,sha256=ZArJb1qqZlvo_YhX-qqwUonRvhLevMWoiA9aS1fEYiw,800
+kanen_infer/api.py,sha256=FLu6mS8_zgWChuXToeVzuF9pqXJ-UFI1pbKYOn8eHU8,7801
+kanen_infer/arjuna_cli.py,sha256=9zew3ZrazqLH_X1VX_eWLqJ6u8i9cdc-JN8mRBNuIa4,7047
+kanen_infer/assemble.py,sha256=7ka81_ajbx1MQu5oYCifm5aO86NzwBWGGwX56xZiASo,18787
+kanen_infer/batch_pipeline.py,sha256=x3_bJpidJqEPfq39r1dhzfDovfsw-Zjr-o8SoxB3hFU,17855
+kanen_infer/charset.py,sha256=k8cFqDWlYcmrCOH9n5IAR-bAEx_VKy04_ZSRBkbnE-Q,3468
+kanen_infer/cli.py,sha256=m7_OcXUL7rLqiq17dSYd4ocU6QqA8R_DWL38LcoTMqo,5318
+kanen_infer/config.py,sha256=lIYv7RmrOUy77w66zpiOPELW31yzbzoJNLEdyC5NHeI,5906
+kanen_infer/formats.py,sha256=9TK4MrsGM3lRlIaWAOYwXI1_O4-85DrE7kcce4mQ52Q,5493
+kanen_infer/geometry.py,sha256=4_QCbMxlaK0cq2RkJVIWu3vVUFiHmnkG2vd79-6eSX4,833
+kanen_infer/hardware.py,sha256=SjnnivDjY7VLQNZQd4MTZLfHzkDbK7vluEXPKP68mGM,11113
+kanen_infer/io.py,sha256=ozEicuwW3BBxg95oLojmT4YL-SFD7nsOQO-rKoMtdcQ,3777
+kanen_infer/models.py,sha256=CC4B6Fc8EMrauPJ9cyz0-vMPgz7Bm7SOM2zWn8Kfew4,2907
+kanen_infer/pipeline_base.py,sha256=dehRXLg9tyHSwHB8yEo-smLn67DrSb2FtMyd__BBHbo,18089
+kanen_infer/providers.py,sha256=ergf0-l-25qxBsWFwrZzRVYsr6bRcq03jz7GUv2ciAY,15773
+kanen_infer/rec_onnx.py,sha256=XMaKAyPHdDFEKoU9eT9b0Bj6lwy51GauGWyDBiqyc90,5435
+arjuna_ocr-1.2.1.dist-info/METADATA,sha256=UTPRhcvTAD9ZNG0C39RfCXrHNLrHUTUtclTunmBzsJQ,3713
+arjuna_ocr-1.2.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+arjuna_ocr-1.2.1.dist-info/entry_points.txt,sha256=NxHPJ_pJafnXexiIWrjUkLOgrXpxkogV7Ver1hDiajM,122
+arjuna_ocr-1.2.1.dist-info/top_level.txt,sha256=1L1zgtkQPi2eDHA4MRpJIXVvWDYXg3NqhE-b9yh6tRI,12
+arjuna_ocr-1.2.1.dist-info/RECORD,,

arjuna_ocr-1.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

arjuna_ocr-1.2.1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+arjuna = kanen_infer.arjuna_cli:main
+arjuna-ocr = kanen_infer.cli:main
+kanen-ocr = kanen_infer.cli:main

arjuna_ocr-1.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,3 @@
+Apache License 2.0 — see https://www.apache.org/licenses/LICENSE-2.0
+
+Copyright 2026 Chethan (anandkaman). Base models: PaddleOCR (Apache-2.0), OpenOCR SVTRv2 (Apache-2.0).

arjuna_ocr-1.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+kanen_infer

kanen_infer/__init__.py

@@ -0,0 +1,9 @@
+"""Arjuna-OCR [Kn&En] inference package (Kannada + English document OCR): ONNX Runtime + optional TensorRT, no PyTorch."""
+from pathlib import Path as _P
+try: __version__ = (_P(__file__).resolve().parent.parent / "VERSION").read_text(encoding="utf-8").strip()
+except Exception: __version__ = "1.2.1"
+NAME = "Arjuna-OCR [Kn&En]"   # product display name — also `name:` in kanen.yaml (the config value wins at run time)
+from .config import load_config, PKG_ROOT          # noqa: E402
+from .api import KanEnOCR                          # noqa: E402
+from .formats import to_json, to_markdown, to_text, to_hocr, to_alto, to_tsv, render   # noqa: E402
+__all__ = ["KanEnOCR", "load_config", "PKG_ROOT", "NAME", "__version__", "to_json", "to_markdown", "to_text", "to_hocr", "to_alto", "to_tsv", "render"]

kanen_infer/api.py

@@ -0,0 +1,119 @@
+"""Arjuna-OCR [Kn&En] Python API.
+
+    from kanen_infer import KanEnOCR
+    ocr = KanEnOCR()                       # loads kanen.yaml, builds/validates engines (warm-up), see ocr.ready()
+    doc = ocr.page("scan.png")             # one kanen-ocr/1.0 document (dict)
+    docs = ocr.pages(["a.png", "b.pdf"])   # batched; ocr.stream(...) yields documents as they finish
+    boxes = ocr.detect(img)                # text-line polygons only
+    texts = ocr.recognize(crops)           # [(text, conf, min_conf)] for line images
+    blocks = ocr.layout(img)               # layout blocks only
+    ocr.render(doc, "hocr")                # json | md | txt | hocr | alto | tsv
+
+Inputs: file path, bytes, numpy BGR array, PIL image, file object; PDFs through `pages()`/`stream()` (pypdfium2 or pdftoppm,
+optional). The output document never depends on the provider or the batch composition beyond fp16 noise on garbage lines;
+no confidence filtering, no text rewriting, no re-ordering happens here."""
+import logging, time
+import numpy as np, cv2
+from pathlib import Path
+from .config import load_config, PKG_ROOT
+from .providers import Providers
+from .rec_onnx import KanEnRecognizer
+from .pipeline_base import Detector, Layout, crop
+from .batch_pipeline import BatchOCR
+from .io import to_bgr, expand_inputs, iter_page_sources
+from . import formats
+
+LOG = logging.getLogger("kanen")
+
+class KanEnOCR:
+    def __init__(self, config=None, providers=None, layout_mode=None, workers=None, warmup=True, **overrides):
+        """config: path to a kanen.yaml/json, a dict, or None (package default). providers: 'trt' | 'cuda' | 'cpu' | 'auto'
+        (overrides config provider.policy). Other keyword overrides use dotted section names, e.g. layout={'mode': 'auto'}."""
+        ov = dict(overrides)
+        if providers: ov.setdefault("provider", {})["policy"] = providers
+        if layout_mode: ov.setdefault("layout", {})["mode"] = layout_mode
+        if workers: ov.setdefault("runtime", {})["workers"] = workers
+        self.cfg = load_config(config, ov); self.name = self.cfg.get("name", "Arjuna-OCR [Kn&En]"); self.version = str(self.cfg.get("version", "1.0.0"))
+        t0 = time.time(); self.prov = Providers(self.cfg)
+        self.rec = KanEnRecognizer(cfg=self.cfg, providers=self.prov); self.det = Detector(self.cfg, self.prov)
+        self.lay = Layout(self.cfg, self.prov) if self.cfg["layout"].get("mode", "always") != "never" else None
+        self.batch = BatchOCR(self.rec, cfg=self.cfg, providers=self.prov, det=self.det, lay=self.lay)
+        self._load_s = round(time.time() - t0, 1); self._warm = None
+        if warmup: self.warmup()
+
+    # ---- status --------------------------------------------------------------------------------------------------
+    def warmup(self):
+        """Run the bundled self-test page through the full pipeline once: builds/validates TensorRT engines for the
+        default shapes (layout self-test, detector canvas, recognizer profile) so the first real page is not slow."""
+        t0 = time.time(); p = self.cfg.path("models", "layout_selftest")
+        if p.exists():
+            img = to_bgr(str(p)); self.batch.run([img], page_batch=1, loader=lambda x: x)
+        self._warm = round(time.time() - t0, 1); return self.ready()
+
+    def optimize(self, wait=False, timeout=None):
+        """Build the TensorRT engines for this machine in the background and swap them in once each one is validated
+        against the session it replaces. Safe to call at any time; returns immediately unless `wait` is set.
+        Long-lived processes (server, endpoint handler, batch jobs) should call this at startup: the pipeline keeps
+        serving on the CUDA provider meanwhile, and gets 2-3x faster when the engines are ready."""
+        n = self.prov.start_background_builds() if hasattr(self.prov, "start_background_builds") else 0
+        if wait and n: return self.prov.wait_for_engines(timeout)
+        return {"builds_started": n}
+
+    def ready(self):
+        """Provider each model ended on, fallbacks that happened, engine-cache state, model hashes."""
+        st = self.prov.summary()
+        if self.lay is not None: st.setdefault("layout", {})["engine"] = self.lay.stage
+        return {"name": self.name, "version": self.version, "config": self.cfg.source, "gpu": self.prov.gpu, "tensorrt": self.prov.trt_ver,
+                "providers": st, "events": list(self.prov.events), "engine_cache": str(self.prov.cache_root), "load_s": self._load_s, "warmup_s": self._warm,
+                "model": dict(self.batch.model_ids)}
+
+    # ---- full documents -------------------------------------------------------------------------------------------
+    def page(self, image, polygons=None, dpi=None):
+        """Single page (latency path): one kanen-ocr/1.0 document."""
+        img = to_bgr(image); docs, _ = self.batch.process([img], dpi=dpi, with_polygons=self._poly(polygons)); d = docs[0]
+        if isinstance(image, (str, Path)): d["page"]["file"] = Path(image).name
+        return d
+
+    def pages(self, inputs, page_batch=None, polygons=None, pdf_dpi=200):
+        """Batched: list/dir/glob of image or PDF paths, or a list of arrays / PIL images / bytes -> list of documents."""
+        return [d for d in self.stream(inputs, page_batch, polygons, pdf_dpi)]
+
+    def stream(self, inputs, page_batch=None, polygons=None, pdf_dpi=200):
+        """Generator variant of pages(): yields documents in input order as each page batch completes."""
+        sources = self._sources(inputs, pdf_dpi); labels = [s[0] for s in sources]; items = [s[1] for s in sources]
+        page_batch = page_batch or self.cfg["runtime"].get("page_batch", 8); k = 0
+        for doc, st in self.batch.stream(items, page_batch=page_batch, loader=to_bgr, with_polygons=self._poly(polygons)):
+            if labels[k]: doc["page"]["file"] = labels[k]
+            self.last_stats = st; k += 1; yield doc
+
+    def _sources(self, inputs, pdf_dpi):
+        if isinstance(inputs, (str, Path)) or (isinstance(inputs, (list, tuple)) and inputs and all(isinstance(x, (str, Path)) for x in inputs)):
+            return list(iter_page_sources(expand_inputs(inputs), dpi=pdf_dpi))
+        if isinstance(inputs, (list, tuple)): return [(getattr(x, "name", None) or "", x) for x in inputs]
+        return [("", inputs)]
+
+    def _poly(self, polygons): return bool(self.cfg["runtime"].get("polygons", False)) if polygons is None else bool(polygons)
+
+    # ---- single stages --------------------------------------------------------------------------------------------
+    def detect(self, image):
+        """Text-line detection only -> list of (polygon 4x2 float32 in page pixels, score)."""
+        return self.det(to_bgr(image))
+
+    def recognize(self, crops, batch=None):
+        """Recognition only on a list of line images (any size, BGR or gray) -> [(text, confidence, min_conf)]."""
+        res = self.rec([to_bgr(c) for c in crops], bs=batch)
+        return [(t, float(c), float(getattr(c, "min_char", c))) for t, c in res]
+
+    def layout(self, image):
+        """Layout blocks only -> [{type, score, bbox, order}] (labels: title, text, table, figure, seal, id_panel, header, footer, handwriting)."""
+        if self.lay is None: self.lay = Layout(self.cfg, self.prov); self.batch.lay = self.lay
+        return self.lay(to_bgr(image))[0]
+
+    def crops(self, image, boxes=None):
+        """Perspective line crops for detect() boxes (helper for recognize())."""
+        img = to_bgr(image); boxes = self.detect(img) if boxes is None else boxes
+        return [crop(img, b) for b, _ in boxes]
+
+    # ---- serialisation --------------------------------------------------------------------------------------------
+    def render(self, doc, fmt="json"):
+        return formats.render(doc, fmt)

kanen_infer/arjuna_cli.py

@@ -0,0 +1,111 @@
+"""`arjuna` command line — the deployment front end.
+
+  arjuna doctor                  what this machine can do, what the pipeline will use, and why
+  arjuna ocr page.pdf -o out/    OCR files, directories, globs or PDFs (same engine as kanen-ocr)
+  arjuna serve --port 8080       HTTP server (FastAPI); builds TensorRT engines in the background
+  arjuna bench                   measured pages/s on the bundled sample pages, before and after optimisation
+  arjuna warm                    build and validate the TensorRT engines for this machine, then exit
+
+`ocr` stays on the CUDA/CPU provider for small jobs (a TensorRT build costs more than it saves for a page or two) and
+optimises automatically from `--optimize-after` pages upwards. `serve`, `bench` and `warm` always optimise.
+"""
+import argparse, json, os, sys, time
+
+def _cfg(args):
+    from .config import load_config
+    from . import hardware
+    cfg = load_config(args.config)
+    if getattr(args, "provider", None): cfg["provider"]["policy"] = args.provider
+    changes = [] if getattr(args, "no_autoconfig", False) else hardware.autoconfig(cfg, quality=getattr(args, "quality", None))
+    return cfg, changes
+
+def cmd_doctor(a):
+    from . import hardware
+    cfg, changes = _cfg(a)
+    hw = hardware.probe(cfg["provider"].get("policy")); print(hardware.report(cfg, changes, hw))
+    if a.run:
+        from .api import KanEnOCR
+        import cv2, glob
+        pages = sorted(glob.glob(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "samples", "pages", "*")))[:1]
+        if pages:
+            t = time.time(); ocr = KanEnOCR(config=cfg, warmup=False); load = time.time() - t
+            t = time.time(); doc = ocr.page(cv2.imread(pages[0])); dt = time.time() - t
+            lines = sum(len(b["lines"]) for b in doc["blocks"])
+            print(f"\n  load          {load:.1f}s\n  sample page   {dt:.1f}s, {lines} lines, {len(doc['blocks'])} blocks ({os.path.basename(pages[0])})")
+            print(f"  providers     {json.dumps({k: v['provider'] for k, v in ocr.prov.status.items() if k in ('det', 'rec', 'layout')})}")
+            for e in ocr.prov.events[:6]: print(f"                {e}")
+    return 0
+
+def cmd_warm(a):
+    from .api import KanEnOCR
+    cfg, changes = _cfg(a)
+    print("building TensorRT engines for this machine (this is the one slow step; it is cached afterwards)...", flush=True)
+    t = time.time(); ocr = KanEnOCR(config=cfg, warmup=True)
+    res = ocr.optimize(wait=True, timeout=a.timeout)
+    print(f"done in {time.time() - t:.0f}s: {json.dumps(res)}")
+    print("providers:", json.dumps({k: v["provider"] for k, v in ocr.prov.status.items() if k in ("det", "rec", "layout")}))
+    return 0
+
+def cmd_bench(a):
+    import cv2, glob
+    from .api import KanEnOCR
+    cfg, changes = _cfg(a)
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    pages = sorted(glob.glob(os.path.join(root, "samples", "pages", "*")))
+    if not pages: print("no sample pages bundled"); return 1
+    imgs = [cv2.imread(p) for p in pages] * max(1, a.repeat)
+    ocr = KanEnOCR(config=cfg, warmup=True)
+    def run(tag):
+        t = time.time(); docs = ocr.pages(imgs); dt = time.time() - t
+        print(f"  {tag:<22} {len(imgs)/dt:5.2f} pages/s   ({dt:.1f}s for {len(imgs)} pages, {sum(len(b['lines']) for d in docs for b in d['blocks'])} lines)")
+        return len(imgs) / dt
+    print(f"pages: {len(imgs)} · providers before: {json.dumps({k: v['provider'] for k, v in ocr.prov.status.items() if k in ('det','rec','layout')})}")
+    run("as loaded")
+    ocr.optimize(wait=True, timeout=a.timeout)
+    print(f"providers after: {json.dumps({k: v['provider'] for k, v in ocr.prov.status.items() if k in ('det','rec','layout')})}")
+    run("after optimisation"); run("steady state")
+    return 0
+
+def cmd_serve(a):
+    import importlib.util
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    spec = importlib.util.spec_from_file_location("kanen_serve", os.path.join(root, "serve.py"))
+    mod = importlib.util.module_from_spec(spec); sys.modules["kanen_serve"] = mod; spec.loader.exec_module(mod)
+    return mod.serve(a)
+
+def cmd_ocr(a):
+    from .cli import main as kanen_main
+    argv = ["--input"] + a.inputs + ["--out-dir", a.out_dir, "--format", a.format]
+    for flag, val in (("--page-batch", a.page_batch), ("--workers", a.workers), ("--provider", a.provider), ("--config", a.config)):
+        if val: argv += [flag, str(val)]
+    if a.json_lines: argv.append("--json-lines")
+    if a.quiet: argv.append("--quiet")
+    os.environ["KANEN_OPTIMIZE_AFTER"] = str(a.optimize_after)
+    return kanen_main(argv)
+
+def build_parser():
+    ap = argparse.ArgumentParser(prog="arjuna", description="Arjuna-OCR [Kn&En] — Kannada + English document OCR")
+    ap.add_argument("--version", action="store_true")
+    sub = ap.add_subparsers(dest="cmd")
+    common = lambda p: (p.add_argument("--config", default=None), p.add_argument("--provider", choices=["auto", "trt", "cuda", "cpu"], default=None),
+                        p.add_argument("--quality", choices=["fast", "balanced", "exact"], default=None), p.add_argument("--no-autoconfig", action="store_true"))
+    d = sub.add_parser("doctor", help="hardware, providers, auto-configuration"); common(d); d.add_argument("--run", action="store_true", help="also OCR one bundled page"); d.set_defaults(fn=cmd_doctor)
+    w = sub.add_parser("warm", help="build + validate the TensorRT engines, then exit"); common(w); w.add_argument("--timeout", type=int, default=1800); w.set_defaults(fn=cmd_warm)
+    b = sub.add_parser("bench", help="measured pages/s on the bundled pages"); common(b); b.add_argument("--repeat", type=int, default=4); b.add_argument("--timeout", type=int, default=1800); b.set_defaults(fn=cmd_bench)
+    s = sub.add_parser("serve", help="HTTP server"); common(s); s.add_argument("--host", default="0.0.0.0"); s.add_argument("--port", type=int, default=8080)
+    s.add_argument("--workers", type=int, default=None); s.add_argument("--layout-mode", choices=["always", "auto", "never"], default=None); s.set_defaults(fn=cmd_serve)
+    o = sub.add_parser("ocr", help="OCR files / directories / globs / PDFs"); common(o)
+    o.add_argument("inputs", nargs="+"); o.add_argument("--out-dir", "-o", default="arjuna_out"); o.add_argument("--format", "-f", default="json")
+    o.add_argument("--page-batch", type=int, default=None); o.add_argument("--workers", type=int, default=None); o.add_argument("--json-lines", action="store_true")
+    o.add_argument("--quiet", "-q", action="store_true"); o.add_argument("--optimize-after", type=int, default=8, help="build TensorRT engines when a job has at least this many pages")
+    o.set_defaults(fn=cmd_ocr)
+    return ap
+
+def main(argv=None):
+    a = build_parser().parse_args(argv)
+    if a.version:
+        from . import __version__; print(__version__); return 0
+    if not getattr(a, "fn", None): build_parser().print_help(); return 0
+    return a.fn(a)
+
+if __name__ == "__main__": sys.exit(main())

kanen_infer/assemble.py

@@ -0,0 +1,261 @@
+"""Assembler: layout blocks (Arjuna layout v12) + text-line polygons + recognised text -> kanen-ocr/1.0 JSON.
+Pure geometry, no model. Also: Markdown / plain-text renderers."""
+import numpy as np
+from .charset import script_of
+import re
+WEAK_CHAR = 0.50   # min-char confidence below which a line is flagged weak_char (calibrated on 3,478 dev lines: < 0.5 -> 65 % exact)
+_MIX_RE = re.compile(r"(?=\S*[A-Za-z])(?=\S*[\u0C85-\u0CB9])\S+")   # token with both a Latin letter and a Kannada letter
+
+TYPE_MAP = {"doc_title": "title", "paragraph_title": "section_title", "text": "text", "abstract": "text", "content": "text", "reference": "text",
+            "reference_content": "text", "aside_text": "text", "vertical_text": "text", "footnote": "footnote", "vision_footnote": "footnote",
+            "header": "header", "footer": "footer", "number": "page_number", "table": "table", "image": "figure", "chart": "figure",
+            "figure_title": "figure_caption", "seal": "seal", "display_formula": "formula", "inline_formula": "formula", "formula_number": "formula",
+            "algorithm": "text", "header_image": "figure", "footer_image": "figure",
+            "title": "title", "figure": "figure", "id_panel": "id_panel", "handwriting": "handwriting"}   # v1.2 layout classes (text/table/seal/header/footer map 1:1 above)
+
+def _bbox(poly): p = np.asarray(poly, np.float32); return [float(p[:, 0].min()), float(p[:, 1].min()), float(p[:, 0].max()), float(p[:, 1].max())]
+
+def _overlap_frac(line_bb, block_bb):
+    ix = max(0, min(line_bb[2], block_bb[2]) - max(line_bb[0], block_bb[0])); iy = max(0, min(line_bb[3], block_bb[3]) - max(line_bb[1], block_bb[1]))
+    return ix * iy / max((line_bb[2] - line_bb[0]) * (line_bb[3] - line_bb[1]), 1e-6)
+
+def merge_line_fragments(lines, y_tol=0.5, x_gap=1.5):
+    """Merge horizontally adjacent boxes on the same baseline (detector sometimes splits a line at wide gaps).
+    lines: list of dict(bbox, polygon, text, conf). Returns merged list."""
+    lines = sorted(lines, key=lambda l: (l["bbox"][1], l["bbox"][0])); out = []
+    for l in lines:
+        merged = False
+        for m in out:
+            h = min(m["bbox"][3] - m["bbox"][1], l["bbox"][3] - l["bbox"][1])
+            same_row = abs((m["bbox"][1] + m["bbox"][3]) / 2 - (l["bbox"][1] + l["bbox"][3]) / 2) < y_tol * h
+            gap = l["bbox"][0] - m["bbox"][2]
+            if same_row and -0.2 * h < gap < x_gap * h:
+                m["bbox"] = [min(m["bbox"][0], l["bbox"][0]), min(m["bbox"][1], l["bbox"][1]), max(m["bbox"][2], l["bbox"][2]), max(m["bbox"][3], l["bbox"][3])]
+                m["text"] = (m["text"] + " " + l["text"]).strip(); m["confidence"] = min(m["confidence"], l["confidence"]); m["min_conf"] = min(m.get("min_conf", 1), l.get("min_conf", 1)); m["polygon"] = None; merged = True; break
+        if not merged: out.append(dict(l))
+    return out
+
+def xy_cut_order(blocks, page_w):
+    """Fallback reading order: column split then top-to-bottom."""
+    if not blocks: return []
+    mid = page_w / 2
+    left = [b for b in blocks if b["bbox"][2] < mid * 1.05]; right = [b for b in blocks if b["bbox"][0] > mid * 0.95]
+    spanning = [b for b in blocks if b not in left and b not in right]
+    if len(left) >= 2 and len(right) >= 2 and not spanning:
+        return sorted(left, key=lambda b: b["bbox"][1]) + sorted(right, key=lambda b: b["bbox"][1])
+    return sorted(blocks, key=lambda b: (round(b["bbox"][1] / 20), b["bbox"][0]))
+
+def rows_of(lines, tol=0.5):
+    """Cluster line boxes into visual rows (y-centre within tol x the smaller height), left-to-right inside a row."""
+    ls = sorted(lines, key=lambda l: (l["bbox"][1] + l["bbox"][3]) / 2); rows = []
+    for l in ls:
+        yc = (l["bbox"][1] + l["bbox"][3]) / 2; h = l["bbox"][3] - l["bbox"][1]
+        if rows:
+            r = rows[-1]; ryc = np.mean([(m["bbox"][1] + m["bbox"][3]) / 2 for m in r]); rh = np.median([m["bbox"][3] - m["bbox"][1] for m in r])
+            if abs(yc - ryc) < tol * min(h, rh): r.append(l); continue
+        rows.append([l])
+    return [sorted(r, key=lambda l: l["bbox"][0]) for r in rows]
+
+def split_row_by_gap(r, max_gap_h=2.5):
+    """Split a visual row into runs where the horizontal gap between neighbours exceeds max_gap_h x line height: two
+    columns (Kannada | English on ID cards, label | value pairs far apart) must stay separate lines; fragments of one
+    justified/spaced line (gaps of a few glyph widths) still join. Geometry only."""
+    r = sorted(r, key=lambda l: l["bbox"][0]); runs = [[r[0]]]
+    for l in r[1:]:
+        prev = runs[-1][-1]; h = max(8.0, min(prev["bbox"][3] - prev["bbox"][1], l["bbox"][3] - l["bbox"][1]))
+        if l["bbox"][0] - prev["bbox"][2] > max_gap_h * h: runs.append([l])
+        else: runs[-1].append(l)
+    return runs
+
+def join_row(r):
+    """One text line per visual row: fragments of a justified/spaced line are joined with single spaces."""
+    if len(r) == 1: return dict(r[0])
+    return {"bbox": [min(l["bbox"][0] for l in r), min(l["bbox"][1] for l in r), max(l["bbox"][2] for l in r), max(l["bbox"][3] for l in r)],
+            "polygon": None, "text": " ".join(l["text"] for l in r).strip(), "confidence": min(l["confidence"] for l in r), "min_conf": min(l.get("min_conf", 1) for l in r)}
+
+def _runs(mask1d, min_gap=3):
+    idx = np.flatnonzero(mask1d)
+    if idx.size == 0: return []
+    out = []; start = idx[0]; prev = idx[0]
+    for i in idx[1:]:
+        if i - prev > min_gap: out.append((start + prev) / 2); start = i
+        prev = i
+    out.append((start + prev) / 2); return out
+
+def _rule_positions(mask, axis, min_len):
+    """Centre coordinate of every connected component of a rule mask longer than min_len along `axis` (robust to residual tilt)."""
+    import cv2
+    n, _, st, cen = cv2.connectedComponentsWithStats(mask, connectivity=8)
+    pos = sorted(cen[i][1 - axis] for i in range(1, n) if st[i][cv2.CC_STAT_WIDTH if axis == 0 else cv2.CC_STAT_HEIGHT] >= min_len)
+    out = []
+    for p in pos:
+        if out and p - out[-1] < 6: out[-1] = (out[-1] + p) / 2
+        else: out.append(p)
+    return out
+
+def _merge_continuations(rows):
+    """A row whose cells all sit under occupied columns of the previous row and none in its first column is a wrapped cell."""
+    out = []
+    for r in rows:
+        ne = [c for c in r["cells"] if c["text"]]
+        if out and ne:
+            prev = out[-1]; pne = [c for c in prev["cells"] if c["text"]]
+            first = min(c["col"] for c in prev["cells"]) if prev["cells"] else 0
+            if all(c["col"] > first for c in ne) and all(any(p["col"] == c["col"] for p in pne) for c in ne):
+                for c in ne:
+                    p = next(p for p in pne if p["col"] == c["col"]); p["text"] = (p["text"] + " " + c["text"]).strip()
+                    p["bbox"] = [min(p["bbox"][0], c["bbox"][0]), min(p["bbox"][1], c["bbox"][1]), max(p["bbox"][2], c["bbox"][2]), max(p["bbox"][3], c["bbox"][3])]
+                continue
+        out.append(r)
+    return out
+
+def ruled_grid(gray, bbox, lines):
+    """Table structure from printed ruling lines (morphological opening + connected components). Horizontal rules give row
+    bands; inside a band, vertical rules give cells - or, when a band has no vertical rules (aligned-column forms), each
+    visual row of the band becomes a table row whose cells are the separate line boxes. Returns
+    rows=[{cells:[{col,text,bbox,confidence}], ruled}] or None when the region has no horizontal rules. Pure geometry."""
+    import cv2
+    x0, y0, x1, y1 = [int(round(v)) for v in bbox]; reg = gray[max(0, y0):y1, max(0, x0):x1]
+    if reg.size == 0 or reg.shape[0] < 20 or reg.shape[1] < 20: return None
+    H, W = reg.shape; bw = cv2.adaptiveThreshold(reg, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 31, 9)
+    hor = cv2.morphologyEx(bw, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_RECT, (max(20, W // 30), 1)))
+    hor = cv2.dilate(hor, cv2.getStructuringElement(cv2.MORPH_RECT, (max(20, W // 8), 1)))   # bridge faint / dashed rules (text-derived runs are rejected below)
+    loc = [(l["bbox"][0] - x0, l["bbox"][1] - y0, l["bbox"][2] - x0, l["bbox"][3] - y0) for l in lines]
+    def through_text(y): return any(b + 0.1 * (d - b) < y < d - 0.1 * (d - b) for a, b, c, d in loc)   # a rule never crosses the middle of a text line
+    def through_text_x(x, ia, ib): return any(a + 0.1 * (c - a) < x < c - 0.1 * (c - a) and b < ib and d > ia for a, b, c, d in loc)
+    hr = [y for y in _rule_positions(hor, 0, 0.25 * W) if 0.01 * H + 4 < y < H - 0.01 * H - 4 and not through_text(y)]
+    if not hr: return None
+    ys = [0.0] + hr + [float(H)]; bands = []
+    for a, b in zip(ys[:-1], ys[1:]):
+        ia, ib = int(a), int(b)
+        if ib - ia < 8: continue
+        ver = cv2.morphologyEx(bw[ia:ib], cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_RECT, (1, max(8, int((ib - ia) * 0.4)))))
+        ver = cv2.dilate(ver, cv2.getStructuringElement(cv2.MORPH_RECT, (1, max(6, int((ib - ia) * 0.25)))))
+        vr = [x for x in _rule_positions(ver, 1, 0.85 * (ib - ia)) if 0.03 * W < x < 0.97 * W and not through_text_x(x, ia, ib)]   # cell borders span the band, never cross text; table border excluded
+        bands.append((ia, ib, vr))
+    allx = sorted(x for _, _, vr in bands for x in vr); G = []
+    for x in allx:
+        if not G or x - G[-1][-1] > 12: G.append([x])
+        else: G[-1].append(x)
+    G = [float(np.mean(g)) for g in G]
+    def gcol(x): return sum(1 for g in G if g < x + 6)
+    rows = []
+    for ia, ib, vr in bands:
+        inband = [l for l in lines if ia <= (l["bbox"][1] + l["bbox"][3]) / 2 - y0 < ib]
+        if not inband: continue
+        if vr:   # ruled cells: everything between two vertical rules is one cell (a wrapped cell keeps its lines together);
+            # the global rule set is used so a band whose faint rule was missed still gets the table's columns
+            xs = [0.0] + G + [float(W)]
+            percol = [[l for l in inband if ca <= (l["bbox"][0] + l["bbox"][2]) / 2 - x0 < cb] for ca, cb in zip(xs[:-1], xs[1:])]
+            multi = sum(1 for inc in percol if len(rows_of(inc)) > 1)
+            # several columns stacked -> the band holds several table rows whose separating rule was not printed/found
+            groups = rows_of(inband) if multi >= 2 else [inband]
+            for g in groups:
+                cells = []
+                for ca, cb in zip(xs[:-1], xs[1:]):
+                    inc = [l for l in g if ca <= (l["bbox"][0] + l["bbox"][2]) / 2 - x0 < cb]
+                    if not inc: cells.append({"col": gcol(ca), "text": "", "bbox": None, "confidence": None}); continue
+                    cells.append({"col": gcol(ca), "text": " ".join(join_row(r)["text"] for r in rows_of(inc)), "bbox": [min(l["bbox"][0] for l in inc), min(l["bbox"][1] for l in inc), max(l["bbox"][2] for l in inc), max(l["bbox"][3] for l in inc)], "confidence": min(l["confidence"] for l in inc)})
+                rows.append({"cells": cells, "ruled": True})
+            if len(groups) > 1: rows[-len(groups):] = _merge_continuations(rows[-len(groups):])
+        else:    # no vertical rules in this band: each visual row is a table row, each line box a cell
+            for r in rows_of(inband):
+                rows.append({"cells": [{"col": (gcol(l["bbox"][0] - x0) if G else ci), "text": l["text"], "bbox": l["bbox"], "confidence": l["confidence"]} for ci, l in enumerate(r)], "ruled": False})
+    return rows if rows else None
+
+def group_table(lines):
+    """Unruled tables: rows by y-clustering, columns by clustering cell x-starts; a row that only continues cells of the
+    previous row (no cell in the first column, every cell under an occupied column) is a wrapped cell -> merged upward."""
+    if not lines: return []
+    rows = rows_of(lines)
+    spans = sorted(((l["bbox"][0], l["bbox"][2]) for r in rows for l in r)); cols = []
+    for a, b in spans:   # columns = groups of horizontally overlapping cells (works for left/centre/right alignment)
+        if cols and a < cols[-1][1] - 4: cols[-1][1] = max(cols[-1][1], b)
+        else: cols.append([a, b])
+    def col_of(l):
+        xc = (l["bbox"][0] + l["bbox"][2]) / 2
+        return next((i for i, (a, b) in enumerate(cols) if a - 4 <= xc <= b + 4), int(np.argmin([abs(xc - (a + b) / 2) for a, b in cols])) if cols else 0)
+    return _merge_continuations([{"cells": [{"bbox": l["bbox"], "text": l["text"], "confidence": l["confidence"], "col": col_of(l)} for l in r], "ruled": False} for r in rows])
+
+def assemble(page_w, page_h, layout_blocks, det_boxes, texts, model_ids, timing=None, page_index=0, dpi=None, with_polygons=True, img=None):
+    """layout_blocks: [{type, score, bbox, order}], det_boxes: [(poly4x2, score)], texts: [(text, conf)] aligned with det_boxes."""
+    lines = []
+    for (poly, dscore), (text, conf) in zip(det_boxes, texts):
+        if not text.strip(): continue
+        lines.append({"bbox": _bbox(poly), "polygon": [[float(x), float(y)] for x, y in poly] if with_polygons else None, "text": text, "confidence": round(float(conf), 4),
+                      "min_conf": round(float(getattr(conf, "min_char", None) if getattr(conf, "min_char", None) is not None else conf), 4)})
+    blocks = []
+    for i, b in enumerate(layout_blocks):
+        blocks.append({"id": f"b{i}", "type": TYPE_MAP.get(b["type"], "other"), "raw_type": b["type"], "confidence": round(float(b["score"]), 4), "bbox": [round(v, 1) for v in b["bbox"]], "order": b.get("order", i), "lines": []})
+    # assign lines to best-overlapping block; unassigned lines become their own text blocks
+    orphans = []
+    area = lambda bb: max(1.0, (bb[2] - bb[0]) * (bb[3] - bb[1]))
+    for l in lines:
+        best, bi = 0.0, -1
+        for i, b in enumerate(blocks):
+            f = _overlap_frac(l["bbox"], b["bbox"])
+            # nested blocks (v1.2 layout: a handwriting / seal / id_panel box inside a text region): on a near-tie the
+            # smaller, more specific block wins, so signature fragments are not glued to the surrounding text rows
+            if f > best + 0.05 or (f >= best - 0.05 and bi >= 0 and f >= 0.5 and area(b["bbox"]) < area(blocks[bi]["bbox"])): best, bi = f, i
+        if best >= 0.5: blocks[bi]["lines"].append(l)
+        else: orphans.append(l)
+    for l in orphans:
+        blocks.append({"id": f"b{len(blocks)}", "type": "text", "raw_type": "orphan_line", "confidence": l["confidence"], "bbox": [round(v, 1) for v in l["bbox"]], "order": None, "lines": [l]})
+    blocks = [b for b in blocks if b["lines"] or b["type"] in ("figure", "seal", "table", "id_panel", "handwriting")]
+    # order: native rank where available, else xy-cut; orphans placed by position among ordered blocks
+    ranked = [b for b in blocks if b["order"] is not None]; unranked = [b for b in blocks if b["order"] is None]
+    ordered = sorted(ranked, key=lambda b: b["order"])
+    for b in unranked:
+        pos = next((k for k, o in enumerate(ordered) if o["bbox"][1] > b["bbox"][1] and o["bbox"][0] <= b["bbox"][2]), len(ordered)); ordered.insert(pos, b)
+    if not ranked: ordered = xy_cut_order(blocks, page_w)
+    full = []
+    gray = None
+    if img is not None:
+        import cv2; gray = img if img.ndim == 2 else cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    heights = [l["bbox"][3] - l["bbox"][1] for b in ordered for l in b["lines"]]; med_h = float(np.median(heights)) if heights else 0.0
+    for k, b in enumerate(ordered):
+        b["order"] = k
+        if b["type"] == "table":
+            # table cells stay separate boxes; structure from printed rules when present, else from alignment
+            b["lines"] = [l for r in rows_of(b["lines"]) for l in r]
+            rows = ruled_grid(gray, b["bbox"], b["lines"]) if gray is not None else None
+            b["rows"] = rows or group_table(b["lines"]); b["ruled"] = bool(rows)
+        else:
+            b["lines"] = [join_row(run) for r in rows_of(b["lines"]) for run in split_row_by_gap(r)]   # one text line per visual row run (fragments of a spaced line re-joined; wide-gap columns kept apart)
+        for li, l in enumerate(b["lines"]):
+            l["id"] = f"{b['id']}.l{li}"; l["script"] = script_of(l["text"]); l["bbox"] = [round(v, 1) for v in l["bbox"]]
+            # review flags (never deletion): calibration on 5,478 labelled lines -> conf >= 0.99 is 97.7 % line-exact,
+            # 0.95-0.98 only 83.5 %; lines inside seal/figure/header blocks are mostly stamp/handwriting fragments
+            fl = []
+            if l["confidence"] < 0.90: fl.append("low_conf")
+            elif l["confidence"] < 0.98: fl.append("check")
+            if b["type"] in ("seal", "figure", "handwriting", "id_panel"): fl.append("in_" + b["type"])
+            # review flags (script/character-repertoire checks); flags only, the text is never altered
+            if l.get("min_conf", 1.0) < WEAK_CHAR: fl.append("weak_char")                      # one very uncertain character (garbage lines usually have one)
+            if _MIX_RE.search(l["text"]): fl.append("script_mix")                               # Latin and Kannada letters inside one token (other-script garbage)
+            if med_h and (l["bbox"][3] - l["bbox"][1]) > 3.0 * med_h: fl.append("oversize")     # stray ornament / drop-cap sized line
+            if fl: l["flags"] = fl
+        if b["type"] == "table" and b["rows"]: block_text = "\n".join(" | ".join(c["text"] for c in r["cells"]) for r in b["rows"])
+        else: block_text = "\n".join(l["text"] for l in b["lines"])
+        if block_text.strip(): full.append(block_text)
+    return {"schema": "kanen-ocr/1.0", "model": model_ids, "page": {"index": page_index, "width": page_w, "height": page_h, "dpi": dpi, "rotation": 0},
+            "blocks": ordered, "text": "\n\n".join(full), "timing_ms": timing or {}}
+
+def to_markdown(doc):
+    out = []
+    for b in doc["blocks"]:
+        t = b["type"]; txt = " ".join(l["text"] for l in b["lines"]).strip()
+        if t == "title": out.append(f"# {txt}")
+        elif t == "section_title": out.append(f"## {txt}")
+        elif t == "table" and b.get("rows"):
+            ncol = max((c["col"] for r in b["rows"] for c in r["cells"]), default=0) + 1
+            rows = []
+            for r in b["rows"]:
+                cells = [""] * ncol
+                for c in r["cells"]: cells[c["col"]] = (cells[c["col"]] + " " + c["text"]).strip()
+                rows.append("| " + " | ".join(x.replace("|", "\\|") for x in cells) + " |")
+            if rows: out.append(rows[0] + "\n|" + "---|" * ncol + "\n" + "\n".join(rows[1:]))
+        elif t in ("figure", "seal"): out.append(f"*[{t}]*")
+        elif t in ("header", "footer", "page_number"): out.append(f"<sub>{txt}</sub>")
+        elif txt: out.append(txt)
+    return "\n\n".join(out) + "\n"