prettypipeline-ocr 0.1.0__tar.gz

prettypipeline_ocr-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PrettyPipeline contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

prettypipeline_ocr-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: prettypipeline-ocr
+Version: 0.1.0
+Summary: Turn PDFs into structured JSON with local OCR and a cheap cloud LLM.
+Author: greatshoor
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/virajshoor/PrettyPipeline
+Keywords: ocr,pdf,llm,extraction,json
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pymupdf>=1.24
+Requires-Dist: transformers<5,>=4.57.1
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: pillow
+Requires-Dist: openai>=1.0
+Requires-Dist: einops
+Requires-Dist: addict
+Requires-Dist: easydict
+Requires-Dist: safetensors
+Requires-Dist: tqdm
+Requires-Dist: matplotlib
+Requires-Dist: requests
+Dynamic: license-file
+
+# PrettyPipeline
+
+Turn PDFs into structured JSON. OCR runs **locally**; field extraction uses a **cheap cloud LLM**.
+
+## Why this is cheap
+
+Cloud OCR APIs charge per page. PrettyPipeline does the expensive vision work on your GPU with [baidu/Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR) (MIT, 3B params, 32K context — a whole PDF in one `infer_multi()` pass). The only API call is [GPT-5.4 nano](https://developers.openai.com/api/docs/models/gpt-5.4-nano) on the resulting text (~$0.20 / 1M input tokens), prompted with **your** JSON schema.
+
+You pay for a small text completion, not for pixels.
+
+```
+PDF  →  PyMuPDF pages  →  Unlimited-OCR (local GPU)  →  raw text
+                                                      ↓
+                              GPT-5.4 nano (OpenAI)  →  JSON
+                                                      ↓
+                              validation             →  needs_review flags
+```
+
+Nulls, model-marked uncertain fields, and OCR that looks garbled are flagged for a human instead of being silently accepted.
+
+## Install
+
+Python **3.10–3.13** (3.12 recommended). NVIDIA GPU (CUDA) or Apple Silicon (MPS). CPU works but is slow.
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+pip install prettypipeline-ocr
+# or from this repo:
+pip install -e .
+```
+
+On NVIDIA Linux, install a CUDA build of PyTorch first if the default wheel is CPU-only:
+
+```bash
+pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
+pip install -e .
+```
+
+The first run downloads `baidu/Unlimited-OCR` from Hugging Face (~6GB).
+
+## Usage
+
+```bash
+export OPENAI_API_KEY=sk-...
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json -o out.json
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json --ocr-only
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json --device mps
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json --max-length 2048
+```
+
+`--schema` is any JSON Schema. Swap the file to extract a different document type — nothing is hardcoded.
+
+Device is auto-detected (`cuda` → `mps` → `cpu`). Override with `--device`.
+
+On Apple Silicon, Unlimited-OCR can start looping (it hardcodes CUDA). Use `--max-length 2048` for short docs. NVIDIA CUDA is the model's native path.
+
+## Output
+
+```json
+{
+  "data": { "date": "…", "vendor": "…", "line_items": [], "total": 0 },
+  "needs_review": [{ "field": "tax", "reason": "null" }],
+  "ocr_text": "…"
+}
+```
+
+## License
+
+MIT. Unlimited-OCR is also MIT.

prettypipeline_ocr-0.1.0/README.md

@@ -0,0 +1,71 @@
+# PrettyPipeline
+
+Turn PDFs into structured JSON. OCR runs **locally**; field extraction uses a **cheap cloud LLM**.
+
+## Why this is cheap
+
+Cloud OCR APIs charge per page. PrettyPipeline does the expensive vision work on your GPU with [baidu/Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR) (MIT, 3B params, 32K context — a whole PDF in one `infer_multi()` pass). The only API call is [GPT-5.4 nano](https://developers.openai.com/api/docs/models/gpt-5.4-nano) on the resulting text (~$0.20 / 1M input tokens), prompted with **your** JSON schema.
+
+You pay for a small text completion, not for pixels.
+
+```
+PDF  →  PyMuPDF pages  →  Unlimited-OCR (local GPU)  →  raw text
+                                                      ↓
+                              GPT-5.4 nano (OpenAI)  →  JSON
+                                                      ↓
+                              validation             →  needs_review flags
+```
+
+Nulls, model-marked uncertain fields, and OCR that looks garbled are flagged for a human instead of being silently accepted.
+
+## Install
+
+Python **3.10–3.13** (3.12 recommended). NVIDIA GPU (CUDA) or Apple Silicon (MPS). CPU works but is slow.
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+pip install prettypipeline-ocr
+# or from this repo:
+pip install -e .
+```
+
+On NVIDIA Linux, install a CUDA build of PyTorch first if the default wheel is CPU-only:
+
+```bash
+pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
+pip install -e .
+```
+
+The first run downloads `baidu/Unlimited-OCR` from Hugging Face (~6GB).
+
+## Usage
+
+```bash
+export OPENAI_API_KEY=sk-...
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json -o out.json
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json --ocr-only
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json --device mps
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json --max-length 2048
+```
+
+`--schema` is any JSON Schema. Swap the file to extract a different document type — nothing is hardcoded.
+
+Device is auto-detected (`cuda` → `mps` → `cpu`). Override with `--device`.
+
+On Apple Silicon, Unlimited-OCR can start looping (it hardcodes CUDA). Use `--max-length 2048` for short docs. NVIDIA CUDA is the model's native path.
+
+## Output
+
+```json
+{
+  "data": { "date": "…", "vendor": "…", "line_items": [], "total": 0 },
+  "needs_review": [{ "field": "tax", "reason": "null" }],
+  "ocr_text": "…"
+}
+```
+
+## License
+
+MIT. Unlimited-OCR is also MIT.

prettypipeline_ocr-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "prettypipeline-ocr"
+version = "0.1.0"
+description = "Turn PDFs into structured JSON with local OCR and a cheap cloud LLM."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10,<3.14"
+authors = [{ name = "greatshoor" }]
+keywords = ["ocr", "pdf", "llm", "extraction", "json"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+]
+dependencies = [
+    "pymupdf>=1.24",
+    "transformers>=4.57.1,<5",
+    "torch",
+    "torchvision",
+    "pillow",
+    "openai>=1.0",
+    "einops",
+    "addict",
+    "easydict",
+    "safetensors",
+    "tqdm",
+    "matplotlib",
+    "requests",
+]
+
+[project.urls]
+Homepage = "https://github.com/virajshoor/PrettyPipeline"
+
+[project.scripts]
+prettypipeline = "prettypipeline.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

prettypipeline_ocr-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

prettypipeline_ocr-0.1.0/src/prettypipeline/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

prettypipeline_ocr-0.1.0/src/prettypipeline/cli.py

@@ -0,0 +1,65 @@
+"""CLI: prettypipeline run <file.pdf> --schema <schema.json>"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from prettypipeline.extract import needs_review, require_api_key, structure
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(
+        prog="prettypipeline",
+        description="PDF → local OCR → cheap LLM JSON extraction.",
+    )
+    sub = p.add_subparsers(dest="cmd", required=True)
+    run = sub.add_parser("run", help="OCR a PDF and extract JSON using a schema")
+    run.add_argument("pdf", type=Path)
+    run.add_argument("--schema", type=Path, required=True)
+    run.add_argument("-o", "--output", type=Path, help="Write JSON here (also printed)")
+    run.add_argument("--ocr-only", action="store_true", help="Skip the cloud structuring step")
+    run.add_argument("--device", choices=("cuda", "mps", "cpu"), default="", help="Override auto device")
+    run.add_argument("--dpi", type=int, default=300)
+    run.add_argument("--max-length", type=int, default=32768, help="OCR generation cap (model supports 32768)")
+    args = p.parse_args(argv)
+
+    if args.cmd != "run":
+        p.print_help()
+        return 2
+    if not args.pdf.is_file():
+        print(f"not a file: {args.pdf}", file=sys.stderr)
+        return 2
+    schema = json.loads(args.schema.read_text())
+    from prettypipeline.ocr import ocr_pdf, pick_device
+
+    device = args.device or str(pick_device())
+    print(f"OCR device: {device}", file=sys.stderr)
+    text = ocr_pdf(str(args.pdf), dpi=args.dpi, device=args.device, max_length=args.max_length)
+    if args.ocr_only:
+        result = {"ocr_text": text, "data": None, "needs_review": []}
+        _emit(result, args.output)
+        return 0
+    require_api_key()
+    extracted = structure(text, schema)
+    result = {
+        "data": extracted["data"],
+        "needs_review": needs_review(extracted["data"], text, extracted["uncertain_fields"]),
+        "ocr_text": text,
+    }
+    _emit(result, args.output)
+    return 0
+
+
+def _emit(result: dict, output: Path | None) -> None:
+    blob = json.dumps(result, indent=2, ensure_ascii=False)
+    print(blob)
+    if output:
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(blob + "\n")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

prettypipeline_ocr-0.1.0/src/prettypipeline/extract.py

@@ -0,0 +1,138 @@
+"""Cheap cloud structuring (GPT-5.4 nano) plus local review flags."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any
+
+from openai import OpenAI
+
+MODEL = "gpt-5.4-nano"
+API_KEY_ENV = "OPENAI_API_KEY"
+
+_GARBLED = re.compile(r"[\ufffd]|[^\w\s.,:$€£¥%/@+#()\\-]{4,}")
+
+
+def require_api_key() -> str:
+    key = os.environ.get(API_KEY_ENV, "").strip()
+    if not key:
+        raise SystemExit(
+            f"{API_KEY_ENV} is not set. Export it, then re-run:\n"
+            f"  export {API_KEY_ENV}=sk-...\n"
+            f"  prettypipeline run <file.pdf> --schema <schema.json>"
+        )
+    return key
+
+
+def _clean_ocr(ocr_text: str) -> str:
+    text = re.sub(r"<\|det\|>.*?<\|/det\|>", " ", ocr_text, flags=re.DOTALL)
+    return re.sub(r"<PAGE>", "\n", text)
+
+
+def structure(ocr_text: str, schema: dict[str, Any], api_key: str | None = None) -> dict[str, Any]:
+    client = OpenAI(api_key=api_key or require_api_key())
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "Extract fields from OCR text into JSON. "
+                "Return exactly: {\"data\": <object matching the schema>, "
+                "\"uncertain_fields\": [<dotted paths you are not confident about>]}. "
+                "Use null when a required or optional field is missing or unreadable. "
+                "Do not invent values. Prefer null over a guess. "
+                "Ignore repeated garbage tokens from OCR degeneration."
+            ),
+        },
+        {
+            "role": "user",
+            "content": (
+                "JSON schema (target shape for data):\n"
+                f"{json.dumps(schema, indent=2)}\n\n"
+                "OCR text:\n"
+                f"{_clean_ocr(ocr_text)}"
+            ),
+        },
+    ]
+    resp = client.chat.completions.create(
+        model=MODEL,
+        messages=messages,
+        response_format={"type": "json_object"},
+    )
+    raw = resp.choices[0].message.content or "{}"
+    parsed = json.loads(raw)
+    data = parsed.get("data", parsed)
+    uncertain = parsed.get("uncertain_fields") or []
+    if not isinstance(uncertain, list):
+        uncertain = []
+    cleaned_uncertain = []
+    for x in uncertain:
+        path = str(x)
+        if path.startswith("data."):
+            path = path[5:]
+        cleaned_uncertain.append(path)
+    return {"data": data, "uncertain_fields": cleaned_uncertain}
+
+
+def _walk(obj: Any, prefix: str = "") -> list[tuple[str, Any]]:
+    out: list[tuple[str, Any]] = []
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            path = f"{prefix}.{k}" if prefix else k
+            out.extend(_walk(v, path))
+    elif isinstance(obj, list):
+        for i, v in enumerate(obj):
+            out.extend(_walk(v, f"{prefix}[{i}]"))
+    else:
+        out.append((prefix, obj))
+    return out
+
+
+def looks_garbled(value: str) -> bool:
+    if not value or not str(value).strip():
+        return False
+    s = str(value)
+    if s.count("\ufffd") >= 1:
+        return True
+    if _GARBLED.search(s):
+        return True
+    alnum = sum(c.isalnum() for c in s)
+    return len(s) >= 8 and alnum / len(s) < 0.35
+
+
+def ocr_near_field_garbled(ocr_text: str, value: str) -> bool:
+    if not value or not ocr_text:
+        return False
+    needle = str(value).strip()
+    if len(needle) < 3:
+        return False
+    idx = ocr_text.lower().find(needle.lower())
+    if idx < 0:
+        return False
+    window = ocr_text[max(0, idx - 40) : idx + len(needle) + 40]
+    return looks_garbled(window)
+
+
+def needs_review(
+    data: Any,
+    ocr_text: str = "",
+    uncertain: list[str] | None = None,
+) -> list[dict[str, str]]:
+    flags: list[dict[str, str]] = []
+    seen: set[tuple[str, str]] = set()
+
+    def add(field: str, reason: str) -> None:
+        key = (field, reason)
+        if key not in seen:
+            seen.add(key)
+            flags.append({"field": field, "reason": reason})
+
+    for path in uncertain or []:
+        add(path, "uncertain")
+    for path, value in _walk(data):
+        if value is None:
+            add(path, "null")
+        elif isinstance(value, str) and (looks_garbled(value) or ocr_near_field_garbled(ocr_text, value)):
+            add(path, "garbled_ocr")
+    return flags

prettypipeline_ocr-0.1.0/src/prettypipeline/ocr.py

@@ -0,0 +1,132 @@
+"""Local OCR via baidu/Unlimited-OCR (Transformers). CUDA, Apple Silicon MPS, or CPU."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+from functools import lru_cache
+
+import pymupdf as fitz
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+MODEL_ID = "baidu/Unlimited-OCR"
+
+
+def pick_device(explicit: str | None = None) -> torch.device:
+    if explicit:
+        return torch.device(explicit)
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    if getattr(torch.backends, "mps", None) is not None and torch.backends.mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
+
+
+def _patch_cuda_calls(device: torch.device) -> None:
+    """Unlimited-OCR hardcodes Tensor.cuda() and autocast('cuda')."""
+    if device.type == "cuda":
+        return
+
+    target = device
+
+    def _tensor_cuda(self, *args, **kwargs):
+        return self.to(target)
+
+    def _module_cuda(self, *args, **kwargs):
+        return self.to(target)
+
+    _orig_autocast = torch.autocast
+
+    def _autocast(device_type=None, dtype=None, *args, **kwargs):
+        if device_type == "cuda":
+            if device.type == "mps":
+                kwargs.pop("device_type", None)
+                try:
+                    return _orig_autocast("mps", dtype=dtype, *args, **kwargs)
+                except TypeError:
+                    return _orig_autocast("cpu", dtype=dtype, *args, **kwargs)
+            return _orig_autocast("cpu", dtype=dtype, *args, **kwargs)
+        return _orig_autocast(device_type, dtype=dtype, *args, **kwargs)
+
+    torch.Tensor.cuda = _tensor_cuda  # type: ignore[method-assign]
+    torch.nn.Module.cuda = _module_cuda  # type: ignore[method-assign]
+    torch.autocast = _autocast  # type: ignore[assignment]
+
+
+def _dtype_for(device: torch.device) -> torch.dtype:
+    if device.type == "cuda":
+        return torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+    if device.type == "mps":
+        return torch.bfloat16
+    return torch.float32
+
+
+def pdf_to_images(pdf_path: str, dpi: int = 300) -> tuple[list[str], str]:
+    """Rasterize PDF pages the way Unlimited-OCR documents: PyMuPDF at `dpi`."""
+    tmp_dir = tempfile.mkdtemp(prefix="pdf_ocr_")
+    doc = fitz.open(pdf_path)
+    mat = fitz.Matrix(dpi / 72, dpi / 72)
+    paths = []
+    try:
+        for i, page in enumerate(doc):
+            out = os.path.join(tmp_dir, f"page_{i + 1:04d}.png")
+            page.get_pixmap(matrix=mat).save(out)
+            paths.append(out)
+    except Exception:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        raise
+    finally:
+        doc.close()
+    if not paths:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        raise ValueError(f"no pages in {pdf_path}")
+    return paths, tmp_dir
+
+
+@lru_cache(maxsize=1)
+def load_model(device_str: str = "") -> tuple[object, object, torch.device]:
+    device = pick_device(device_str or None)
+    _patch_cuda_calls(device)
+    os.environ.setdefault("PYTORCH_ENABLE_MPS_FALLBACK", "1")
+    dtype = _dtype_for(device)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
+    model = AutoModel.from_pretrained(
+        MODEL_ID,
+        trust_remote_code=True,
+        use_safetensors=True,
+        torch_dtype=dtype,
+    )
+    model = model.eval().to(device)
+    return model, tokenizer, device
+
+
+def ocr_pdf(
+    pdf_path: str,
+    dpi: int = 300,
+    device: str = "",
+    output_dir: str | None = None,
+    max_length: int = 32768,
+) -> str:
+    model, tokenizer, _ = load_model(device)
+    paths, tmp_dir = pdf_to_images(pdf_path, dpi=dpi)
+    out = output_dir or tempfile.mkdtemp(prefix="ocr_out_")
+    own_out = output_dir is None
+    try:
+        text, _tokens = model.infer_multi(
+            tokenizer,
+            prompt="<image>Multi page parsing.",
+            image_files=paths,
+            output_path=out,
+            image_size=1024,
+            max_length=max_length,
+            no_repeat_ngram_size=35,
+            ngram_window=1024,
+            save_results=False,
+        )
+        return text
+    finally:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        if own_out:
+            shutil.rmtree(out, ignore_errors=True)

prettypipeline_ocr-0.1.0/src/prettypipeline_ocr.egg-info/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: prettypipeline-ocr
+Version: 0.1.0
+Summary: Turn PDFs into structured JSON with local OCR and a cheap cloud LLM.
+Author: greatshoor
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/virajshoor/PrettyPipeline
+Keywords: ocr,pdf,llm,extraction,json
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pymupdf>=1.24
+Requires-Dist: transformers<5,>=4.57.1
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: pillow
+Requires-Dist: openai>=1.0
+Requires-Dist: einops
+Requires-Dist: addict
+Requires-Dist: easydict
+Requires-Dist: safetensors
+Requires-Dist: tqdm
+Requires-Dist: matplotlib
+Requires-Dist: requests
+Dynamic: license-file
+
+# PrettyPipeline
+
+Turn PDFs into structured JSON. OCR runs **locally**; field extraction uses a **cheap cloud LLM**.
+
+## Why this is cheap
+
+Cloud OCR APIs charge per page. PrettyPipeline does the expensive vision work on your GPU with [baidu/Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR) (MIT, 3B params, 32K context — a whole PDF in one `infer_multi()` pass). The only API call is [GPT-5.4 nano](https://developers.openai.com/api/docs/models/gpt-5.4-nano) on the resulting text (~$0.20 / 1M input tokens), prompted with **your** JSON schema.
+
+You pay for a small text completion, not for pixels.
+
+```
+PDF  →  PyMuPDF pages  →  Unlimited-OCR (local GPU)  →  raw text
+                                                      ↓
+                              GPT-5.4 nano (OpenAI)  →  JSON
+                                                      ↓
+                              validation             →  needs_review flags
+```
+
+Nulls, model-marked uncertain fields, and OCR that looks garbled are flagged for a human instead of being silently accepted.
+
+## Install
+
+Python **3.10–3.13** (3.12 recommended). NVIDIA GPU (CUDA) or Apple Silicon (MPS). CPU works but is slow.
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+pip install prettypipeline-ocr
+# or from this repo:
+pip install -e .
+```
+
+On NVIDIA Linux, install a CUDA build of PyTorch first if the default wheel is CPU-only:
+
+```bash
+pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
+pip install -e .
+```
+
+The first run downloads `baidu/Unlimited-OCR` from Hugging Face (~6GB).
+
+## Usage
+
+```bash
+export OPENAI_API_KEY=sk-...
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json -o out.json
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json --ocr-only
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json --device mps
+prettypipeline run invoice.pdf --schema examples/invoice.schema.json --max-length 2048
+```
+
+`--schema` is any JSON Schema. Swap the file to extract a different document type — nothing is hardcoded.
+
+Device is auto-detected (`cuda` → `mps` → `cpu`). Override with `--device`.
+
+On Apple Silicon, Unlimited-OCR can start looping (it hardcodes CUDA). Use `--max-length 2048` for short docs. NVIDIA CUDA is the model's native path.
+
+## Output
+
+```json
+{
+  "data": { "date": "…", "vendor": "…", "line_items": [], "total": 0 },
+  "needs_review": [{ "field": "tax", "reason": "null" }],
+  "ocr_text": "…"
+}
+```
+
+## License
+
+MIT. Unlimited-OCR is also MIT.

prettypipeline_ocr-0.1.0/src/prettypipeline_ocr.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/prettypipeline/__init__.py
+src/prettypipeline/cli.py
+src/prettypipeline/extract.py
+src/prettypipeline/ocr.py
+src/prettypipeline_ocr.egg-info/PKG-INFO
+src/prettypipeline_ocr.egg-info/SOURCES.txt
+src/prettypipeline_ocr.egg-info/dependency_links.txt
+src/prettypipeline_ocr.egg-info/entry_points.txt
+src/prettypipeline_ocr.egg-info/requires.txt
+src/prettypipeline_ocr.egg-info/top_level.txt
+tests/test_review.py

prettypipeline_ocr-0.1.0/src/prettypipeline_ocr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

prettypipeline_ocr-0.1.0/src/prettypipeline_ocr.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+prettypipeline = prettypipeline.cli:main

prettypipeline_ocr-0.1.0/src/prettypipeline_ocr.egg-info/requires.txt

@@ -0,0 +1,13 @@
+pymupdf>=1.24
+transformers<5,>=4.57.1
+torch
+torchvision
+pillow
+openai>=1.0
+einops
+addict
+easydict
+safetensors
+tqdm
+matplotlib
+requests

prettypipeline_ocr-0.1.0/src/prettypipeline_ocr.egg-info/top_level.txt

@@ -0,0 +1 @@
+prettypipeline

prettypipeline_ocr-0.1.0/tests/test_review.py

@@ -0,0 +1,21 @@
+from prettypipeline.extract import looks_garbled, needs_review
+
+
+def test_null_uncertain_garbled():
+    data = {"date": None, "vendor": "Acme", "total": "@@@@####~~~~xx"}
+    flags = needs_review(data, ocr_text="Acme invoice", uncertain=["vendor"])
+    reasons = {(f["field"], f["reason"]) for f in flags}
+    assert ("date", "null") in reasons
+    assert ("vendor", "uncertain") in reasons
+    assert ("total", "garbled_ocr") in reasons
+
+
+def test_clean_string_not_garbled():
+    assert not looks_garbled("Acme Corp")
+    assert looks_garbled("bad\ufffdtext")
+
+
+if __name__ == "__main__":
+    test_null_uncertain_garbled()
+    test_clean_string_not_garbled()
+    print("ok")