g-ocr 0.1.0__py3-none-any.whl

g_ocr/__init__.py

@@ -0,0 +1,18 @@
+"""GOCR — schnelle, kleine deutsche OCR-/Vision-Schicht (CPU, kein GPU).
+
+Ganzes Dokument -> Text + Position (bbox) als strukturiertes JSON.
+Bilder (png/jpg/webp/tiff/bmp ...) und PDF (Plugin: pip install g-ocr[pdf]).
+
+    import g_ocr
+    ocr = g_ocr.from_pretrained()               # lädt die GOCR-Gewichte (HF)
+    res = ocr.read("dokument.png")              # eine Seite
+    doc = ocr.read_document("rechnung.pdf")     # mehrseitig (PDF/Bild)
+    # -> {text, regions:[{text, box:[x0,y0,x1,y1], quad, score}], ...}
+"""
+__version__ = "0.1.0"
+
+from .pipeline import GOCR, read, read_document          # noqa: F401
+from .pretrained import from_pretrained, DEFAULT_HF_REPO  # noqa: F401
+
+__all__ = ["GOCR", "read", "read_document", "from_pretrained",
+           "DEFAULT_HF_REPO", "__version__"]

g_ocr/cli.py

@@ -0,0 +1,41 @@
+"""GOCR CLI:  g-ocr datei.(png|jpg|webp|tiff|pdf ...)  ->  Text + bbox als JSON."""
+import argparse
+import json
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        prog="g-ocr",
+        description="GOCR — deutsche OCR: Dokument -> Text + Position (bbox). "
+                    "Bilder (png/jpg/webp/tiff/bmp ...) und PDF.")
+    ap.add_argument("path", help="Bild- oder PDF-Pfad")
+    ap.add_argument("--repo", default=None, help="HF-Repo der GOCR-Gewichte")
+    ap.add_argument("--det", help="Detektor-ONNX (statt --repo)")
+    ap.add_argument("--rec", help="Recognizer-ONNX (statt --repo)")
+    ap.add_argument("--charset", help="Charset-Datei (statt --repo)")
+    ap.add_argument("--drop-score", type=float, default=0.4)
+    ap.add_argument("--max-pages", type=int, default=500, help="PDF: max. Seiten")
+    ap.add_argument("--dpi", type=int, default=200, help="PDF: Render-DPI")
+    ap.add_argument("--text-only", action="store_true", help="nur Text ausgeben")
+    a = ap.parse_args()
+
+    from .pipeline import GOCR
+    if a.det and a.rec and a.charset:
+        ocr = GOCR(a.det, a.rec, a.charset, drop_score=a.drop_score)
+    else:
+        from .pretrained import from_pretrained
+        ocr = from_pretrained(repo=a.repo, drop_score=a.drop_score)
+
+    from .formats import is_pdf
+    if is_pdf(a.path):
+        res = ocr.read_document(a.path, max_pages=a.max_pages, dpi=a.dpi)
+    else:
+        res = ocr.read(a.path)
+
+    # Beide Schemata haben ein Top-Level-"text" (Volltext / über alle Seiten).
+    print(res["text"] if a.text_only
+          else json.dumps(res, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

g_ocr/formats.py

@@ -0,0 +1,76 @@
+"""GOCR-Eingabeformate — pluggbare Loader für Bilder und PDF.
+
+Bilder (png/jpg/webp/tiff/bmp/gif ...) laufen über Pillow (Core-Dep).
+PDF ist ein **optionales Plugin**:  pip install g-ocr[pdf]  (pypdfium2).
+
+Erweiterbar: weitere Formate via LOADERS-Registry (Endung -> Loader-Funktion,
+die ein BGR-numpy-Array bzw. einen Seiten-Generator liefert).
+"""
+import os
+import numpy as np
+
+# Vom Pillow-Decoder abgedeckte Einzelbild-Formate.
+IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".webp", ".tif", ".tiff",
+             ".bmp", ".gif", ".ppm", ".pgm", ".jp2"}
+PDF_EXTS = {".pdf"}
+
+
+def _ext(path):
+    return os.path.splitext(path)[1].lower() if isinstance(path, str) else ""
+
+
+def _pil_to_bgr(im):
+    """PIL-Image -> BGR-numpy (wie cv2.imread, RGB->BGR)."""
+    arr = np.asarray(im.convert("RGB"))
+    return np.ascontiguousarray(arr[:, :, ::-1])
+
+
+def load_image(path):
+    """Bild-Datei -> BGR-numpy. Robust inkl. webp/tiff/bmp/gif (Pillow)."""
+    from PIL import Image
+    try:
+        with Image.open(path) as im:
+            return _pil_to_bgr(im)
+    except Exception as e:                       # klare Fehlermeldung statt None
+        raise ValueError(f"GOCR: Bild nicht lesbar: {path} ({e})") from e
+
+
+def is_pdf(path):
+    return _ext(path) in PDF_EXTS
+
+
+def is_image(path):
+    return _ext(path) in IMAGE_EXTS
+
+
+def iter_pdf_pages(path, dpi=200, max_pages=500):
+    """PDF -> Generator je Seite:  (index, total_seiten, bgr_numpy).
+
+    Optionales Plugin:  pip install g-ocr[pdf]  (pypdfium2).
+    Sehr große PDFs werden bei max_pages begrenzt (total wird trotzdem gemeldet).
+    """
+    try:
+        import pypdfium2 as pdfium
+    except ImportError as e:
+        raise ImportError(
+            "GOCR: PDF-Support benötigt das optionale Plugin 'pypdfium2'.\n"
+            "      Installieren:  pip install g-ocr[pdf]"
+        ) from e
+
+    pdf = pdfium.PdfDocument(path)
+    try:
+        total = len(pdf)
+        n = min(total, max(0, int(max_pages)))
+        scale = dpi / 72.0                       # PDF-Basis = 72 DPI
+        for i in range(n):
+            page = pdf[i]
+            bitmap = page.render(scale=scale)
+            pil = bitmap.to_pil()
+            yield i, total, _pil_to_bgr(pil)
+            page.close()
+    finally:
+        pdf.close()
+
+
+# Registry: Endung -> ("image"|"pdf"). Für künftige Formate hier erweitern.
+LOADERS = {**{e: "image" for e in IMAGE_EXTS}, **{e: "pdf" for e in PDF_EXTS}}

g_ocr/pipeline.py

@@ -0,0 +1,283 @@
+"""GOCR-Engine — Detektor (DB) + Recognizer (CTC), reines ONNX / CPU.
+
+Eigenständige Inferenz-Pipeline (kein Fremd-OCR-Import):
+  ocr = GOCR(det_onnx, rec_onnx, charset)
+  ocr.read(img)            -> {engine, version, image, text, n_regions, regions[box, quad, score]}
+  ocr.read_document(path)  -> mehrseitig (PDF/Bild): {n_pages, pages:[...], text}
+
+Gewichte/Charset sind konfigurierbar (eigene Modelle werden hier eingehängt).
+"""
+import os
+import warnings
+
+import numpy as np
+import cv2
+import onnxruntime as ort
+
+from .formats import load_image, is_pdf, iter_pdf_pages
+
+try:
+    import pyclipper
+    from shapely.geometry import Polygon
+    _HAS_CLIP = True
+except Exception:  # pragma: no cover
+    _HAS_CLIP = False
+
+_MEAN = np.array([0.485, 0.456, 0.406], np.float32)
+_STD = np.array([0.229, 0.224, 0.225], np.float32)
+
+
+# ----------------------------- Charset / CTC -----------------------------
+def load_charset(path):
+    """CTC-Charset: index 0 = blank, dann Dict-Zeilen, am Ende Space."""
+    chars = ["<blank>"]
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            chars.append(line.rstrip("\n"))
+    chars.append(" ")
+    return chars
+
+
+def ctc_greedy_decode(probs, charset):
+    """probs: [T, C] (softmax). Collapse-Repeats + Blank(0) entfernen."""
+    idx = probs.argmax(1)
+    conf = probs.max(1)
+    out, confs, prev = [], [], -1
+    for i, p in zip(idx, conf):
+        if i != 0 and i != prev:
+            if i < len(charset):
+                out.append(charset[i])
+                confs.append(p)
+        prev = i
+    return "".join(out), (float(np.mean(confs)) if confs else 0.0)
+
+
+# ----------------------------- Detektor (DB) -----------------------------
+def _det_preprocess(img_bgr, limit_side_len=960):
+    h, w = img_bgr.shape[:2]
+    ratio = min(1.0, limit_side_len / max(h, w))
+    rh = max(32, int(round(h * ratio / 32)) * 32)
+    rw = max(32, int(round(w * ratio / 32)) * 32)
+    resized = cv2.resize(img_bgr, (rw, rh))
+    x = resized.astype(np.float32) / 255.0
+    x = (x - _MEAN) / _STD
+    return x.transpose(2, 0, 1)[None].astype(np.float32), (h, w, rh, rw)
+
+
+def _order_quad(pts):
+    """4 Punkte -> tl, tr, br, bl."""
+    pts = pts[np.argsort(pts[:, 0])]
+    left = pts[:2][np.argsort(pts[:2, 1])]
+    right = pts[2:][np.argsort(pts[2:, 1])]
+    return np.array([left[0], right[0], right[1], left[1]], np.float32)
+
+
+def _unclip(box, ratio):
+    poly = Polygon(box)
+    if poly.length == 0:
+        return None
+    dist = poly.area * ratio / poly.length
+    off = pyclipper.PyclipperOffset()
+    off.AddPath([tuple(p) for p in box], pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+    res = off.Execute(dist)
+    return np.array(res[0]) if res else None
+
+
+def _box_score_slow(prob, contour):
+    h, w = prob.shape
+    c = contour.reshape(-1, 2).copy()
+    xmin = int(np.clip(c[:, 0].min(), 0, w - 1)); xmax = int(np.clip(c[:, 0].max(), 0, w - 1))
+    ymin = int(np.clip(c[:, 1].min(), 0, h - 1)); ymax = int(np.clip(c[:, 1].max(), 0, h - 1))
+    mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), np.uint8)
+    c[:, 0] -= xmin; c[:, 1] -= ymin
+    cv2.fillPoly(mask, [c.astype(np.int32)], 1)
+    return cv2.mean(prob[ymin:ymax + 1, xmin:xmax + 1], mask)[0]
+
+
+def _db_boxes(prob, shape, thresh=0.3, box_thresh=0.6, unclip_ratio=1.5,
+              max_candidates=1000, min_size=3):
+    h0, w0, rh, rw = shape
+    bitmap = (prob > thresh).astype(np.uint8) * 255
+    contours, _ = cv2.findContours(bitmap, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+    boxes, scores = [], []
+    for contour in contours[:max_candidates]:
+        eps = 0.002 * cv2.arcLength(contour, True)
+        approx = cv2.approxPolyDP(contour, eps, True).reshape(-1, 2)
+        if approx.shape[0] < 4:
+            continue
+        score = _box_score_slow(prob, contour)
+        if score < box_thresh:
+            continue
+        ub = _unclip(approx, unclip_ratio)
+        if ub is None or len(ub) < 4:
+            continue
+        rect = cv2.minAreaRect(ub.reshape(-1, 2).astype(np.float32))
+        if min(rect[1]) < min_size:
+            continue
+        quad = _order_quad(cv2.boxPoints(rect))
+        quad[:, 0] = np.clip(quad[:, 0] / rw * w0, 0, w0)
+        quad[:, 1] = np.clip(quad[:, 1] / rh * h0, 0, h0)
+        boxes.append(quad)
+        scores.append(float(score))
+    return boxes, scores
+
+
+def _reading_order(boxes):
+    """Sortiere Boxen oben→unten, links→rechts (Zeilen-tolerant)."""
+    if not boxes:
+        return []
+    idx = list(range(len(boxes)))
+    tops = [b[:, 1].min() for b in boxes]
+    lefts = [b[:, 0].min() for b in boxes]
+    heights = [max(1, b[:, 1].max() - b[:, 1].min()) for b in boxes]
+    tol = np.median(heights) * 0.6
+    idx.sort(key=lambda i: (round(tops[i] / max(tol, 1)), lefts[i]))
+    return idx
+
+
+def _crop(img, quad):
+    quad = quad.astype(np.float32)
+    wA = np.linalg.norm(quad[0] - quad[1]); wB = np.linalg.norm(quad[3] - quad[2])
+    hA = np.linalg.norm(quad[0] - quad[3]); hB = np.linalg.norm(quad[1] - quad[2])
+    W, H = int(max(wA, wB)), int(max(hA, hB))
+    if W < 1 or H < 1:
+        return None
+    dst = np.array([[0, 0], [W, 0], [W, H], [0, H]], np.float32)
+    crop = cv2.warpPerspective(img, cv2.getPerspectiveTransform(quad, dst), (W, H))
+    if H * 1.0 / W >= 1.5:          # hohe Boxen drehen
+        crop = np.rot90(crop)
+    return crop
+
+
+# ----------------------------- Recognizer (CTC) --------------------------
+def _rec_preprocess(crop_bgr, img_h=48, max_w=320):
+    h, w = crop_bgr.shape[:2]
+    rw = min(max_w, max(1, int(round(img_h * w / max(h, 1)))))
+    resized = cv2.resize(crop_bgr, (rw, img_h))
+    x = (resized.astype(np.float32) / 255.0 - 0.5) / 0.5
+    return x.transpose(2, 0, 1)[None].astype(np.float32)
+
+
+# ----------------------------- GOCR ---------------------------------------
+class GOCR:
+    """Deutsche OCR-Engine: Detektor + Recognizer, reines ONNX/CPU."""
+
+    def __init__(self, det_onnx, rec_onnx, charset, drop_score=0.4,
+                 limit_side_len=960, rec_h=48, rec_max_w=2000, num_threads=None):
+        so = ort.SessionOptions()
+        if num_threads:
+            so.intra_op_num_threads = int(num_threads)
+        prov = ["CPUExecutionProvider"]
+        self.det = ort.InferenceSession(det_onnx, sess_options=so, providers=prov)
+        self.rec = ort.InferenceSession(rec_onnx, sess_options=so, providers=prov)
+        self.det_in = self.det.get_inputs()[0].name
+        self.rec_in = self.rec.get_inputs()[0].name
+        self.charset = charset if isinstance(charset, list) else load_charset(charset)
+        self.drop_score = drop_score
+        self.limit_side_len = limit_side_len
+        self.rec_h, self.rec_max_w = rec_h, rec_max_w
+
+    def detect(self, img_bgr):
+        x, shape = _det_preprocess(img_bgr, self.limit_side_len)
+        prob = self.det.run(None, {self.det_in: x})[0][0, 0]
+        boxes, _ = _db_boxes(prob, shape)
+        return [boxes[i] for i in _reading_order(boxes)]
+
+    def recognize(self, crop_bgr):
+        x = _rec_preprocess(crop_bgr, self.rec_h, self.rec_max_w)
+        probs = self.rec.run(None, {self.rec_in: x})[0][0]
+        return ctc_greedy_decode(probs, self.charset)
+
+    def _to_bgr(self, image):
+        """Pfad (Bild) oder numpy -> BGR-numpy. PDF: siehe read_document()."""
+        if isinstance(image, str):
+            return load_image(image)             # robust inkl. webp (Pillow)
+        arr = np.asarray(image)
+        if arr.ndim == 2:                        # Graustufen -> 3 Kanäle
+            arr = np.stack([arr, arr, arr], -1)
+        if arr.shape[2] == 3:                    # RGB -> BGR (Annahme)
+            arr = arr[:, :, ::-1]
+        return np.ascontiguousarray(arr)
+
+    def _ocr_page(self, img_bgr):
+        """BGR-numpy -> {image, text, n_regions, regions} (eine Seite)."""
+        h, w = img_bgr.shape[:2]
+        regions = []
+        for quad in self.detect(img_bgr):
+            crop = _crop(img_bgr, quad)
+            if crop is None:
+                continue
+            text, score = self.recognize(crop)
+            if not text or score < self.drop_score:
+                continue
+            xs = [int(p[0]) for p in quad]
+            ys = [int(p[1]) for p in quad]
+            regions.append({
+                "id": len(regions),
+                "text": text,
+                "score": round(score, 3),
+                "box": [min(xs), min(ys), max(xs), max(ys)],
+                "quad": [[int(x), int(y)] for x, y in quad],
+            })
+        return {
+            "image": {"width": int(w), "height": int(h)},
+            "text": "\n".join(r["text"] for r in regions),
+            "n_regions": len(regions),
+            "regions": regions,
+        }
+
+    def read(self, image):
+        """Ein Bild (Pfad/numpy) -> strukturiertes GOCR-JSON (eine Seite).
+
+        Schema: {engine, version, image:{width,height}, text, n_regions,
+                 regions:[{id, text, score, box:[x0,y0,x1,y1], quad:[[x,y]x4]}]}
+          - box  = achsenparalleles Rechteck (kompakt)   - quad = 4 Eckpunkte
+          - text = Volltext in Lesereihenfolge (direkt fürs LLM)
+        Bildformate inkl. webp/tiff/bmp. Für PDF/mehrseitig: read_document().
+        """
+        page = self._ocr_page(self._to_bgr(image))
+        return {"engine": "GOCR", "version": "0.1.0", **page}
+
+    def read_document(self, source, max_pages=500, dpi=200):
+        """Bild ODER PDF (Pfad) -> Dokument-JSON über alle Seiten.
+
+        Schema: {engine, version, source, n_pages, n_pages_total, truncated,
+                 text, pages:[{page, image, text, n_regions, regions}]}
+        PDF-Support ist ein optionales Plugin:  pip install g-ocr[pdf].
+        max_pages begrenzt sehr große PDFs (Default 500); truncated +
+        n_pages_total zeigen ehrlich, ob abgeschnitten wurde.
+        """
+        pages = []
+        n_total = 1
+        if is_pdf(source):
+            for i, total, bgr in iter_pdf_pages(source, dpi=dpi, max_pages=max_pages):
+                n_total = total
+                pages.append({"page": i + 1, **self._ocr_page(bgr)})
+        else:
+            pages.append({"page": 1, **self._ocr_page(self._to_bgr(source))})
+        truncated = n_total > len(pages)
+        if truncated:
+            warnings.warn(
+                f"GOCR: nur {len(pages)}/{n_total} Seiten verarbeitet "
+                f"(max_pages={max_pages}).")
+        return {
+            "engine": "GOCR",
+            "version": "0.1.0",
+            "source": source if isinstance(source, str) else "<array>",
+            "n_pages": len(pages),
+            "n_pages_total": n_total,
+            "truncated": truncated,
+            "text": "\n\n".join(p["text"] for p in pages),
+            "pages": pages,
+        }
+
+
+def read(image, det_onnx, rec_onnx, charset, **kw):
+    """Komfort-Funktion (ein Bild)."""
+    return GOCR(det_onnx, rec_onnx, charset, **kw).read(image)
+
+
+def read_document(source, det_onnx, rec_onnx, charset, *, max_pages=500, dpi=200, **kw):
+    """Komfort-Funktion (Bild/PDF, mehrseitig)."""
+    return GOCR(det_onnx, rec_onnx, charset, **kw).read_document(
+        source, max_pages=max_pages, dpi=dpi)

g_ocr/pretrained.py

@@ -0,0 +1,21 @@
+"""GOCR-Gewichte laden (von HuggingFace)."""
+import os
+
+from .pipeline import GOCR
+
+# HF-Repo mit den GOCR-Gewichten (gocr_det.onnx, gocr_rec.onnx, charset.txt).
+DEFAULT_HF_REPO = os.environ.get("GOCR_HF_REPO", "Keyven/g-ocr")
+
+
+def from_pretrained(repo=None, det="gocr_det.onnx", rec="gocr_rec.onnx",
+                    charset="charset.txt", **kwargs):
+    """Lädt Detektor + Recognizer + Charset aus dem HF-Repo und baut die GOCR-Engine.
+
+    kwargs werden an GOCR() durchgereicht (z. B. drop_score, num_threads).
+    """
+    from huggingface_hub import hf_hub_download
+    repo = repo or DEFAULT_HF_REPO
+    det_p = hf_hub_download(repo, det)
+    rec_p = hf_hub_download(repo, rec)
+    cs_p = hf_hub_download(repo, charset)
+    return GOCR(det_p, rec_p, cs_p, **kwargs)

g_ocr-0.1.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: g-ocr
+Version: 0.1.0
+Summary: GOCR — schnelle, kleine deutsche OCR-/Vision-Schicht für Dokumente (CPU, kein GPU): ganzes Dokument → Text + Position (bbox) als JSON. Bilder + PDF.
+Author: Keyvan Hardani
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://german-ocr.de
+Project-URL: Source, https://github.com/Keyvanhardani/g-ocr
+Keywords: ocr,german,deutsch,document,invoice,rechnung,bbox,onnx,cpu
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: onnxruntime>=1.16
+Requires-Dist: numpy
+Requires-Dist: opencv-python-headless
+Requires-Dist: Pillow
+Requires-Dist: pyclipper
+Requires-Dist: shapely
+Requires-Dist: huggingface_hub
+Provides-Extra: pdf
+Requires-Dist: pypdfium2>=4; extra == "pdf"
+Provides-Extra: all
+Requires-Dist: pypdfium2>=4; extra == "all"
+Dynamic: license-file
+
+# GOCR — schnelle, kleine deutsche OCR-/Vision-Schicht (CPU)
+
+Liest ein **ganzes Dokument** zu **Text + Position (bbox)** als strukturiertes JSON —
+**~38 MB, reine CPU, kein GPU**. Gedacht als **OCR-/Vision-Schicht für (text-only) LLM-Pipelines**
+und als **Tooling**: präzise Layout-Boxen + Text rein → dein LLM macht Verständnis/Extraktion.
+
+```bash
+pip install g-ocr           # Bilder: png/jpg/webp/tiff/bmp ...
+pip install "g-ocr[pdf]"    # + PDF-Support (optionales Plugin)
+```
+```python
+import g_ocr
+ocr = g_ocr.from_pretrained()
+res = ocr.read("dokument.png")            # ein Bild      -> {text, regions:[{text, box, quad, score}]}
+doc = ocr.read_document("rechnung.pdf")   # PDF/mehrseitig -> {n_pages, pages:[...], text}
+```
+
+## Stärken
+- 🎯 **Präzise Bounding-Boxes**, ganzes Dokument, Lesereihenfolge → strukturiertes JSON
+- ⚡ **CPU, bis ~16× schneller als EasyOCR** — kein GPU
+- 📦 **~38 MB** · 🧱 **Fraktur-robust** · on-prem/DSGVO · 🤖 **LLM-ready**
+- 🗂️ **Bilder (png/jpg/webp/tiff/bmp …) + PDF** (bis ~500 Seiten) → ein API-Aufruf, JSON pro Seite
+
+## Benchmarks (anerkannte Sets, CPU)
+![GOCR Benchmarks](assets/gocr_benchmarks.png)
+
+**Scene-Text** (Word Accuracy ↑): IIIT5K **93,2 %** · ICDAR2013 **94,1 %** · ICDAR2015 67,6 % — IIIT5K klar vor EasyOCR (68,2 %).
+
+**Dokument-OCR** (CER ↓ / BoW ↓) — Harness [agentic-ai-forge/ocr-benchmark-2025](https://github.com/agentic-ai-forge/ocr-benchmark-2025):
+
+| Engine | SROIE CER | FUNSD CER | SROIE BoW | FUNSD BoW |
+|---|--:|--:|--:|--:|
+| PaddleOCR | **15,2** | **20,3** | **25,8** | **50,5** |
+| **GOCR** | 18,9 | 22,4 | 98,9 | 130,3 |
+| EasyOCR | 20,4 | 26,4 | 81,1 | 102,1 |
+| Tesseract | 22,6 | 32,4 | 70,2 | 88,2 |
+| OCR.space | 44,3 | 48,2 | 73,3 | 84,8 |
+
+**Einordnung:** Auf Dokument-**CER #2 von 5** — vor EasyOCR, Tesseract & OCR.space, knapp hinter PaddleOCR,
+bei ~38 MB auf reiner CPU. Beim Bag-of-Words liegt GOCR zurück (Wort-Spacing der aktuellen Gewichte — Roadmap).
+Fraktur (NewsEye) ≈3× besser als EasyOCR; bei rein-modernem Deutsch führen Spezial-Engines (Umlaut-Lücke).
+*FUNSD = exakte 25 Referenz-Samples, SROIE = 60er-Stichprobe; gescort mit der `metrics.py` des Referenz-Harness.*
+
+## CLI
+```bash
+g-ocr dokument.png              # JSON (text + box + quad)
+g-ocr rechnung.pdf              # PDF -> JSON je Seite (Plugin: g-ocr[pdf])
+g-ocr dokument.png --text-only  # nur Text (Lesereihenfolge)
+```
+
+## Links
+- 🤗 Modell + Card: https://huggingface.co/Keyven/g-ocr
+- 🖥️ Demo: https://huggingface.co/spaces/Keyven/GOCR-Demo
+- 🌐 https://german-ocr.de
+
+## Lizenz
+Apache-2.0 — siehe [`LICENSE`](LICENSE) und [`NOTICE`](NOTICE).

g_ocr-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+g_ocr/__init__.py,sha256=a_ZW4Sv7dSdKOO8pHSYnJpg2o1nBwaMdC5O_STSkHnA,798
+g_ocr/cli.py,sha256=jF_RP3236kelrCy9nvo7OpqYyTkgJEVj4KszctibQMA,1651
+g_ocr/formats.py,sha256=tnCO4oXwyyxB8n_SNHZoO7a9bNIkIOvmlKAP45C78tg,2428
+g_ocr/pipeline.py,sha256=CIaqOBzV2OmSJbKJ-TmiQVsVuPhmW3uUm4B2EzLdYwc,11109
+g_ocr/pretrained.py,sha256=CsDDpv55LMaRWjkxLjRKCp2mYhAuI2TUTPjCPJXI0u8,776
+g_ocr-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+g_ocr-0.1.0.dist-info/licenses/NOTICE,sha256=uXPWcgFEJByQ8UQ8PwiPhcyqAvVEny38PlfLt6iPf54,504
+g_ocr-0.1.0.dist-info/METADATA,sha256=BkLARpjezYn6SgnAFjxCykFpkW3ktuqSz6CsPeXXwYw,3731
+g_ocr-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+g_ocr-0.1.0.dist-info/entry_points.txt,sha256=nvsDYPgB9ed8atw2jH9URhXSL-y-qELxYjY6rW2UcAQ,41
+g_ocr-0.1.0.dist-info/top_level.txt,sha256=cTV5XwzAbPysHq_nesaxKUrCktYOYEgCMqU5UEVHuC0,6
+g_ocr-0.1.0.dist-info/RECORD,,

g_ocr-0.1.0.dist-info/WHEEL

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

g_ocr-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+g-ocr = g_ocr.cli:main

g_ocr-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

g_ocr-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,12 @@
+GOCR
+Copyright (c) 2026 Keyvan Hardani / german-ocr.de
+
+Dieses Produkt steht unter der Apache License 2.0 (siehe LICENSE).
+
+Drittanbieter / Attribution
+---------------------------
+GOCRs Erkenner-Linie "KSVTRv3" wird auf eigenen deutschen Daten trainiert.
+Für vortrainierte Modellgewichte können Komponenten unter Apache License 2.0
+zum Einsatz kommen (Text-Detektion vom Typ DB; Text-Erkennung vom Typ SVTR).
+Diese Werke stehen unter Apache-2.0; die jeweiligen Lizenz- und Urheberhinweise
+gelten fort.

g_ocr-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+g_ocr