tinyocr-onnx 0.1.0__tar.gz

tinyocr_onnx-0.1.0/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 (c) 2016 PaddlePaddle Authors. All Rights Reserved.
+
+   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.

tinyocr_onnx-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE NOTICE README.md
+recursive-include tests *.py *.png

tinyocr_onnx-0.1.0/NOTICE

@@ -0,0 +1,29 @@
+TinyOCR
+Copyright 2026 Maureese Williams
+
+This product includes PaddleOCR / PP-OCRv6 model artifacts.
+Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
+https://github.com/PaddlePaddle/PaddleOCR
+Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+PP-OCRv6_det_tiny.onnx is the unchanged pretrained detector.
+PP-OCRv6_rec_tiny.onnx WAS MODIFIED by Maureese Williams in 2026:
+selected float32 weight tensors were stored as per-channel int8 values with
+constant decoding back to float32. Computation remains float32. No training
+or calibration was performed. This modified file is not an official
+PaddlePaddle release. SHA-256 hashes and origins are in assets/models.json.
+
+Original ONNX artifacts were distributed through RapidAI/RapidOCR v3.10.0:
+https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.10.0/onnx/PP-OCRv6/det/PP-OCRv6_det_tiny.onnx
+https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.10.0/onnx/PP-OCRv6/rec/PP-OCRv6_rec_tiny.onnx
+Official Apache-2.0 model cards:
+https://huggingface.co/PaddlePaddle/PP-OCRv6_tiny_det_onnx
+https://huggingface.co/PaddlePaddle/PP-OCRv6_tiny_rec_onnx
+
+Runtime inference uses the separately installed RapidOCR project (Apache-2.0):
+Copyright RapidAI contributors. https://github.com/RapidAI/RapidOCR
+Other installed dependencies retain their own licenses.
+
+Research repository only: the vendored Google HierText evaluator has its own
+CC BY-SA 4.0 license and notices in third_party/hiertext. It and evaluation
+datasets are not included in the TinyOCR runtime distribution.

tinyocr_onnx-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: tinyocr-onnx
+Version: 0.1.0
+Summary: Offline CPU OCR with 3.10 MB of bundled PaddleOCR-derived ONNX models
+Author: Maureese Williams
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/MMWilliams/tinyocr
+Project-URL: Repository, https://github.com/MMWilliams/tinyocr
+Project-URL: Models, https://huggingface.co/maureesewilliams/tinyocr
+Project-URL: Issues, https://github.com/MMWilliams/tinyocr/issues
+Keywords: ocr,onnx,paddleocr,offline,cpu
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: rapidocr==3.10.0
+Requires-Dist: onnxruntime==1.31.0
+Requires-Dist: numpy==2.5.4
+Requires-Dist: opencv-python-headless==5.0.0.93
+Requires-Dist: pillow==12.3.0
+Requires-Dist: omegaconf==2.4.0
+Dynamic: license-file
+
+# TinyOCR
+
+Offline, English-first CPU OCR with **3.10 MB of bundled ONNX model files**.
+TinyOCR packages a compressed pretrained PaddleOCR PP-OCRv6 recognizer and the
+original tiny detector, using RapidOCR and ONNX Runtime. It is an alpha release,
+not a newly trained model. The full installation and runtime memory are larger
+than the model files.
+
+## Install and use
+
+Python **3.12** is supported. Windows, Linux and macOS are tested in CI.
+
+```sh
+python -m pip install tinyocr-onnx==0.1.0
+tinyocr receipt.png
+tinyocr receipt.png --json
+python -m tinyocr receipt.png --no-words
+```
+
+```python
+from tinyocr import TinyOCR
+
+ocr = TinyOCR()  # Load once and reuse. No model downloads.
+result = ocr("receipt.png")
+print(result.text)
+print(result.lines)     # text, polygon, and [x0, y0, x1, y1] bounds
+print(result.words)     # text and native word polygons
+data = result.to_dict() # JSON-serializable
+```
+
+Inputs are local image paths (PNG, JPEG, and other Pillow-supported images).
+Coordinates are original-image pixels. Text uses a simple geometric row order,
+not document-layout analysis. Blank images produce empty text and region lists.
+`words=False` omits word geometry. Native word polygons can have zero area;
+these are preserved to match the published benchmark.
+
+The package name is **tinyocr-onnx**; the import and CLI are **tinyocr**. Do not
+install the unrelated `tinyocr` distribution into the same environment. When
+using this research checkout, run the installed package outside the repository
+root so the research `tinyocr/` directory does not shadow it.
+
+## Measured tradeoffs
+
+The frozen pair is 3,099,213 bytes versus the original 6,319,431 bytes (50.96%
+smaller). The recognizer stores int8 weights but executes float32 math. This is
+a model-storage reduction; it is not a general speed or RAM reduction.
+
+| Dataset | Images | Original E2E F1 (%) | TinyOCR E2E F1 (%) |
+| --- | ---: | ---: | ---: |
+| SROIE | 341 | 41.036 | 40.779 |
+| TextOCR | 3,027 | 43.412 | 43.334 |
+| HierText | 1,721 | 40.330 | 40.204 |
+
+In one timed pass, candidate p50 latency was 21.23% higher on SROIE, 16.16%
+higher on HierText, and 6.91% lower on TextOCR. Peak process working set was
+about 500 MiB for both models on the measured Windows machine. SROIE/TextOCR
+use the shared HierText polygon protocol, not their native leaderboard scores.
+Public pretraining overlap is unknown; these are comparative development results.
+See the [full benchmark and limitations](https://github.com/MMWilliams/tinyocr/blob/master/BENCHMARK_RESULTS.md).
+
+Inference uses one-thread CPU ONNX sessions, detector maximum side 960 px,
+recognition batch size one, and no orientation classifier. Initialization also
+sets OpenCV and common BLAS thread controls to one for the current process.
+Rotated text, difficult scenes and complex layouts can fail. English-first
+evaluation does not establish multilingual performance. No mobile performance
+claim is made.
+
+## Source and license
+
+[GitHub](https://github.com/MMWilliams/tinyocr) ·
+[Hugging Face models](https://huggingface.co/maureesewilliams/tinyocr) ·
+[PyPI](https://pypi.org/project/tinyocr-onnx/)
+
+Apache-2.0. See LICENSE and NOTICE for PaddlePaddle and RapidAI attribution and
+the recognizer modification notice. Bundled artifacts are verified by SHA-256
+on initialization. No evaluation datasets are included.

tinyocr_onnx-0.1.0/README.md

@@ -0,0 +1,76 @@
+# TinyOCR
+
+Offline, English-first CPU OCR with **3.10 MB of bundled ONNX model files**.
+TinyOCR packages a compressed pretrained PaddleOCR PP-OCRv6 recognizer and the
+original tiny detector, using RapidOCR and ONNX Runtime. It is an alpha release,
+not a newly trained model. The full installation and runtime memory are larger
+than the model files.
+
+## Install and use
+
+Python **3.12** is supported. Windows, Linux and macOS are tested in CI.
+
+```sh
+python -m pip install tinyocr-onnx==0.1.0
+tinyocr receipt.png
+tinyocr receipt.png --json
+python -m tinyocr receipt.png --no-words
+```
+
+```python
+from tinyocr import TinyOCR
+
+ocr = TinyOCR()  # Load once and reuse. No model downloads.
+result = ocr("receipt.png")
+print(result.text)
+print(result.lines)     # text, polygon, and [x0, y0, x1, y1] bounds
+print(result.words)     # text and native word polygons
+data = result.to_dict() # JSON-serializable
+```
+
+Inputs are local image paths (PNG, JPEG, and other Pillow-supported images).
+Coordinates are original-image pixels. Text uses a simple geometric row order,
+not document-layout analysis. Blank images produce empty text and region lists.
+`words=False` omits word geometry. Native word polygons can have zero area;
+these are preserved to match the published benchmark.
+
+The package name is **tinyocr-onnx**; the import and CLI are **tinyocr**. Do not
+install the unrelated `tinyocr` distribution into the same environment. When
+using this research checkout, run the installed package outside the repository
+root so the research `tinyocr/` directory does not shadow it.
+
+## Measured tradeoffs
+
+The frozen pair is 3,099,213 bytes versus the original 6,319,431 bytes (50.96%
+smaller). The recognizer stores int8 weights but executes float32 math. This is
+a model-storage reduction; it is not a general speed or RAM reduction.
+
+| Dataset | Images | Original E2E F1 (%) | TinyOCR E2E F1 (%) |
+| --- | ---: | ---: | ---: |
+| SROIE | 341 | 41.036 | 40.779 |
+| TextOCR | 3,027 | 43.412 | 43.334 |
+| HierText | 1,721 | 40.330 | 40.204 |
+
+In one timed pass, candidate p50 latency was 21.23% higher on SROIE, 16.16%
+higher on HierText, and 6.91% lower on TextOCR. Peak process working set was
+about 500 MiB for both models on the measured Windows machine. SROIE/TextOCR
+use the shared HierText polygon protocol, not their native leaderboard scores.
+Public pretraining overlap is unknown; these are comparative development results.
+See the [full benchmark and limitations](https://github.com/MMWilliams/tinyocr/blob/master/BENCHMARK_RESULTS.md).
+
+Inference uses one-thread CPU ONNX sessions, detector maximum side 960 px,
+recognition batch size one, and no orientation classifier. Initialization also
+sets OpenCV and common BLAS thread controls to one for the current process.
+Rotated text, difficult scenes and complex layouts can fail. English-first
+evaluation does not establish multilingual performance. No mobile performance
+claim is made.
+
+## Source and license
+
+[GitHub](https://github.com/MMWilliams/tinyocr) ·
+[Hugging Face models](https://huggingface.co/maureesewilliams/tinyocr) ·
+[PyPI](https://pypi.org/project/tinyocr-onnx/)
+
+Apache-2.0. See LICENSE and NOTICE for PaddlePaddle and RapidAI attribution and
+the recognizer modification notice. Bundled artifacts are verified by SHA-256
+on initialization. No evaluation datasets are included.

tinyocr_onnx-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=77,<83"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tinyocr-onnx"
+version = "0.1.0"
+description = "Offline CPU OCR with 3.10 MB of bundled PaddleOCR-derived ONNX models"
+readme = "README.md"
+requires-python = ">=3.12,<3.13"
+license = "Apache-2.0"
+license-files = ["LICENSE", "NOTICE"]
+authors = [{name = "Maureese Williams"}]
+keywords = ["ocr", "onnx", "paddleocr", "offline", "cpu"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Image Recognition",
+]
+dependencies = [
+  "rapidocr==3.10.0",
+  "onnxruntime==1.31.0",
+  "numpy==2.5.4",
+  "opencv-python-headless==5.0.0.93",
+  "pillow==12.3.0",
+  "omegaconf==2.4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/MMWilliams/tinyocr"
+Repository = "https://github.com/MMWilliams/tinyocr"
+Models = "https://huggingface.co/maureesewilliams/tinyocr"
+Issues = "https://github.com/MMWilliams/tinyocr/issues"
+
+[project.scripts]
+tinyocr = "tinyocr.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+tinyocr = ["assets/*.onnx", "assets/*.json", "assets/NOTICE"]

tinyocr_onnx-0.1.0/setup.cfg

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

tinyocr_onnx-0.1.0/src/tinyocr/__init__.py

@@ -0,0 +1,6 @@
+"""TinyOCR: offline CPU OCR using bundled, compressed PaddleOCR weights."""
+
+from .runtime import OCRResult, TinyOCR
+
+__version__ = "0.1.0"
+__all__ = ["OCRResult", "TinyOCR", "__version__"]

tinyocr_onnx-0.1.0/src/tinyocr/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

tinyocr_onnx-0.1.0/src/tinyocr/assets/NOTICE

@@ -0,0 +1,29 @@
+TinyOCR
+Copyright 2026 Maureese Williams
+
+This product includes PaddleOCR / PP-OCRv6 model artifacts.
+Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
+https://github.com/PaddlePaddle/PaddleOCR
+Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+PP-OCRv6_det_tiny.onnx is the unchanged pretrained detector.
+PP-OCRv6_rec_tiny.onnx WAS MODIFIED by Maureese Williams in 2026:
+selected float32 weight tensors were stored as per-channel int8 values with
+constant decoding back to float32. Computation remains float32. No training
+or calibration was performed. This modified file is not an official
+PaddlePaddle release. SHA-256 hashes and origins are in assets/models.json.
+
+Original ONNX artifacts were distributed through RapidAI/RapidOCR v3.10.0:
+https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.10.0/onnx/PP-OCRv6/det/PP-OCRv6_det_tiny.onnx
+https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.10.0/onnx/PP-OCRv6/rec/PP-OCRv6_rec_tiny.onnx
+Official Apache-2.0 model cards:
+https://huggingface.co/PaddlePaddle/PP-OCRv6_tiny_det_onnx
+https://huggingface.co/PaddlePaddle/PP-OCRv6_tiny_rec_onnx
+
+Runtime inference uses the separately installed RapidOCR project (Apache-2.0):
+Copyright RapidAI contributors. https://github.com/RapidAI/RapidOCR
+Other installed dependencies retain their own licenses.
+
+Research repository only: the vendored Google HierText evaluator has its own
+CC BY-SA 4.0 license and notices in third_party/hiertext. It and evaluation
+datasets are not included in the TinyOCR runtime distribution.

tinyocr_onnx-0.1.0/src/tinyocr/assets/models.json

@@ -0,0 +1,15 @@
+{
+  "model": "v6-w8-rec",
+  "artifacts": [
+    {
+      "filename": "PP-OCRv6_det_tiny.onnx",
+      "bytes": 1829618,
+      "sha256": "f42c0fbd294d95eac1a550e131b277dac97462c8025fa4b6c3cec1b7894bd3d5"
+    },
+    {
+      "filename": "PP-OCRv6_rec_tiny.onnx",
+      "bytes": 1269595,
+      "sha256": "38cd559cb4b24c5056592d981b13e086f9472db9b3c8968296f0d0c2b4a65531"
+    }
+  ]
+}

tinyocr_onnx-0.1.0/src/tinyocr/cli.py

@@ -0,0 +1,28 @@
+"""Command line interface for local image OCR."""
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from . import TinyOCR, __version__
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description="Offline CPU OCR with bundled TinyOCR models")
+    parser.add_argument("image", type=Path, help="local image path")
+    parser.add_argument("--json", action="store_true", help="emit text, lines and words as JSON")
+    parser.add_argument("--no-words", action="store_true", help="omit word geometry")
+    parser.add_argument("--version", action="version", version=f"tinyocr-onnx {__version__}")
+    args = parser.parse_args(argv)
+    if not args.image.expanduser().is_file():
+        parser.error(f"Image does not exist or is not a file: {args.image}")
+    try:
+        result = TinyOCR()(args.image, words=not args.no_words)
+    except Exception as exc:
+        print(f"tinyocr: {exc}", file=sys.stderr)
+        return 1
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    print(json.dumps(result.to_dict(), ensure_ascii=False) if args.json else result.text)
+    return 0

tinyocr_onnx-0.1.0/src/tinyocr/runtime.py

@@ -0,0 +1,125 @@
+"""Frozen v6-w8-rec pipeline, distributed independently of the research harness."""
+
+from dataclasses import asdict, dataclass
+import hashlib
+import json
+import os
+from pathlib import Path
+import threading
+
+
+@dataclass
+class OCRResult:
+    """Text in row order, line polygons/xyxy bounds, and native word polygons.
+
+    Coordinates are in pixels of the original image. Native word boxes can be
+    degenerate; these are retained to match the published benchmark adapter.
+    """
+
+    text: str
+    lines: list[dict]
+    words: list[dict]
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def _reading_order(regions):
+    # Same half-smaller-height row tolerance as the frozen research adapter.
+    rows = []
+    for region in sorted(regions, key=lambda r: ((r["box"][1] + r["box"][3]) / 2, r["box"][0])):
+        x0, y0, x1, y1 = region["box"]
+        cy, h = (y0 + y1) / 2, y1 - y0
+        if rows and abs(cy - rows[-1][0]) <= 0.5 * min(h, rows[-1][1]):
+            rows[-1][2].append(region)
+        else:
+            rows.append([cy, h, [region]])
+    return [r for _, _, row in rows for r in sorted(row, key=lambda r: r["box"][0])]
+
+
+class TinyOCR:
+    """Reusable, one-thread CPU OCR engine for local image paths.
+
+    Initialization verifies and loads both bundled models. No model download
+    or account is required. Sets OpenCV and common BLAS thread controls to one.
+    Calls on one instance are serialized because RapidOCR updates call options.
+    """
+
+    def __init__(self):
+        for key in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMEXPR_NUM_THREADS"):
+            os.environ[key] = "1"
+
+        import cv2
+        from rapidocr import RapidOCR
+        from rapidocr.utils.typings import LangDet, LangRec, ModelType, OCRVersion
+
+        cv2.setNumThreads(1)
+        cv2.ocl.setUseOpenCL(False)
+        assets = Path(__file__).resolve().parent / "assets"
+        manifest = json.loads((assets / "models.json").read_text(encoding="utf-8"))
+        for item in manifest["artifacts"]:
+            path = assets / item["filename"]
+            if not path.is_file() or hashlib.sha256(path.read_bytes()).hexdigest() != item["sha256"]:
+                raise RuntimeError(f"Bundled model missing or damaged: {path.name}. Reinstall tinyocr-onnx.")
+        params = {
+            "Global.model_root_dir": str(assets),
+            "Global.use_cls": False,
+            "Global.log_level": "warning",
+            "EngineConfig.onnxruntime.intra_op_num_threads": 1,
+            "EngineConfig.onnxruntime.inter_op_num_threads": 1,
+            "EngineConfig.onnxruntime.use_cuda": False,
+            "EngineConfig.onnxruntime.use_dml": False,
+            "Det.ocr_version": OCRVersion.PPOCRV6,
+            "Rec.ocr_version": OCRVersion.PPOCRV6,
+            "Det.model_type": ModelType.TINY,
+            "Rec.model_type": ModelType.TINY,
+            "Det.lang_type": LangDet.CH,
+            "Rec.lang_type": LangRec.EN,
+            "Det.mean": [0.485, 0.456, 0.406],
+            "Det.std": [0.229, 0.224, 0.225],
+            "Det.limit_side_len": 960,
+            "Det.limit_type": "max",
+            "Det.thresh": 0.2,
+            "Det.box_thresh": 0.4,
+            "Det.unclip_ratio": 1.4,
+            "Det.max_candidates": 3000,
+            "Det.use_dilation": False,
+            "Rec.rec_batch_num": 1,
+            "Rec.rec_img_shape": [3, 48, 320],
+            "Det.model_path": str(assets / "PP-OCRv6_det_tiny.onnx"),
+            "Rec.model_path": str(assets / "PP-OCRv6_rec_tiny.onnx"),
+        }
+        self._engine = RapidOCR(params=params)
+        self._engine._load_det_model()
+        self._engine._load_rec_model()
+        for module in (self._engine.text_det, self._engine.text_rec):
+            session = module.session.session
+            opts = session.get_session_options()
+            if (session.get_providers() != ["CPUExecutionProvider"] or
+                    opts.intra_op_num_threads != 1 or opts.inter_op_num_threads != 1):
+                raise RuntimeError("TinyOCR requires one-thread CPU sessions")
+        self._lock = threading.Lock()
+
+    def __call__(self, image: str | os.PathLike, *, words: bool = True) -> OCRResult:
+        """Read a local image. Set words=False to omit native word geometry."""
+        from rapidocr.main import flatten_word_results
+
+        path = Path(image).expanduser()
+        if not path.is_file():
+            raise FileNotFoundError(f"Image does not exist or is not a file: {path}")
+        with self._lock:
+            result = self._engine(str(path), use_det=True, use_cls=False, use_rec=True,
+                                  return_word_box=words, return_single_char_box=False)
+            lines = []
+            if result.boxes is not None:
+                for text, points in zip(result.txts, result.boxes):
+                    polygon = [[float(x), float(y)] for x, y in points]
+                    xs, ys = zip(*polygon)
+                    lines.append({"text": text, "polygon": polygon,
+                                  "box": [min(xs), min(ys), max(xs), max(ys)]})
+            lines = _reading_order(lines)
+            word_regions = [
+                {"text": text, "polygon": [[float(x), float(y)] for x, y in points]}
+                for text, _, points in flatten_word_results(getattr(result, "word_results", None))
+            ] if words else []
+        return OCRResult("\n".join(r["text"] for r in lines), lines, word_regions)

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

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: tinyocr-onnx
+Version: 0.1.0
+Summary: Offline CPU OCR with 3.10 MB of bundled PaddleOCR-derived ONNX models
+Author: Maureese Williams
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/MMWilliams/tinyocr
+Project-URL: Repository, https://github.com/MMWilliams/tinyocr
+Project-URL: Models, https://huggingface.co/maureesewilliams/tinyocr
+Project-URL: Issues, https://github.com/MMWilliams/tinyocr/issues
+Keywords: ocr,onnx,paddleocr,offline,cpu
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: rapidocr==3.10.0
+Requires-Dist: onnxruntime==1.31.0
+Requires-Dist: numpy==2.5.4
+Requires-Dist: opencv-python-headless==5.0.0.93
+Requires-Dist: pillow==12.3.0
+Requires-Dist: omegaconf==2.4.0
+Dynamic: license-file
+
+# TinyOCR
+
+Offline, English-first CPU OCR with **3.10 MB of bundled ONNX model files**.
+TinyOCR packages a compressed pretrained PaddleOCR PP-OCRv6 recognizer and the
+original tiny detector, using RapidOCR and ONNX Runtime. It is an alpha release,
+not a newly trained model. The full installation and runtime memory are larger
+than the model files.
+
+## Install and use
+
+Python **3.12** is supported. Windows, Linux and macOS are tested in CI.
+
+```sh
+python -m pip install tinyocr-onnx==0.1.0
+tinyocr receipt.png
+tinyocr receipt.png --json
+python -m tinyocr receipt.png --no-words
+```
+
+```python
+from tinyocr import TinyOCR
+
+ocr = TinyOCR()  # Load once and reuse. No model downloads.
+result = ocr("receipt.png")
+print(result.text)
+print(result.lines)     # text, polygon, and [x0, y0, x1, y1] bounds
+print(result.words)     # text and native word polygons
+data = result.to_dict() # JSON-serializable
+```
+
+Inputs are local image paths (PNG, JPEG, and other Pillow-supported images).
+Coordinates are original-image pixels. Text uses a simple geometric row order,
+not document-layout analysis. Blank images produce empty text and region lists.
+`words=False` omits word geometry. Native word polygons can have zero area;
+these are preserved to match the published benchmark.
+
+The package name is **tinyocr-onnx**; the import and CLI are **tinyocr**. Do not
+install the unrelated `tinyocr` distribution into the same environment. When
+using this research checkout, run the installed package outside the repository
+root so the research `tinyocr/` directory does not shadow it.
+
+## Measured tradeoffs
+
+The frozen pair is 3,099,213 bytes versus the original 6,319,431 bytes (50.96%
+smaller). The recognizer stores int8 weights but executes float32 math. This is
+a model-storage reduction; it is not a general speed or RAM reduction.
+
+| Dataset | Images | Original E2E F1 (%) | TinyOCR E2E F1 (%) |
+| --- | ---: | ---: | ---: |
+| SROIE | 341 | 41.036 | 40.779 |
+| TextOCR | 3,027 | 43.412 | 43.334 |
+| HierText | 1,721 | 40.330 | 40.204 |
+
+In one timed pass, candidate p50 latency was 21.23% higher on SROIE, 16.16%
+higher on HierText, and 6.91% lower on TextOCR. Peak process working set was
+about 500 MiB for both models on the measured Windows machine. SROIE/TextOCR
+use the shared HierText polygon protocol, not their native leaderboard scores.
+Public pretraining overlap is unknown; these are comparative development results.
+See the [full benchmark and limitations](https://github.com/MMWilliams/tinyocr/blob/master/BENCHMARK_RESULTS.md).
+
+Inference uses one-thread CPU ONNX sessions, detector maximum side 960 px,
+recognition batch size one, and no orientation classifier. Initialization also
+sets OpenCV and common BLAS thread controls to one for the current process.
+Rotated text, difficult scenes and complex layouts can fail. English-first
+evaluation does not establish multilingual performance. No mobile performance
+claim is made.
+
+## Source and license
+
+[GitHub](https://github.com/MMWilliams/tinyocr) ·
+[Hugging Face models](https://huggingface.co/maureesewilliams/tinyocr) ·
+[PyPI](https://pypi.org/project/tinyocr-onnx/)
+
+Apache-2.0. See LICENSE and NOTICE for PaddlePaddle and RapidAI attribution and
+the recognizer modification notice. Bundled artifacts are verified by SHA-256
+on initialization. No evaluation datasets are included.

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

@@ -0,0 +1,22 @@
+LICENSE
+MANIFEST.in
+NOTICE
+README.md
+pyproject.toml
+src/tinyocr/__init__.py
+src/tinyocr/__main__.py
+src/tinyocr/cli.py
+src/tinyocr/runtime.py
+src/tinyocr/assets/NOTICE
+src/tinyocr/assets/PP-OCRv6_det_tiny.onnx
+src/tinyocr/assets/PP-OCRv6_rec_tiny.onnx
+src/tinyocr/assets/models.json
+src/tinyocr_onnx.egg-info/PKG-INFO
+src/tinyocr_onnx.egg-info/SOURCES.txt
+src/tinyocr_onnx.egg-info/dependency_links.txt
+src/tinyocr_onnx.egg-info/entry_points.txt
+src/tinyocr_onnx.egg-info/requires.txt
+src/tinyocr_onnx.egg-info/top_level.txt
+tests/test_installed.py
+tests/fixtures/blank.png
+tests/fixtures/receipt.png

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,6 @@
+rapidocr==3.10.0
+onnxruntime==1.31.0
+numpy==2.5.4
+opencv-python-headless==5.0.0.93
+pillow==12.3.0
+omegaconf==2.4.0

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

@@ -0,0 +1 @@
+tinyocr

tinyocr_onnx-0.1.0/tests/test_installed.py

@@ -0,0 +1,118 @@
+"""Public contracts exercised with actual bundled models and authored images."""
+
+import hashlib
+import importlib.metadata
+import json
+import math
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+import tinyocr
+from tinyocr import TinyOCR
+
+FIXTURES = Path(__file__).parent / "fixtures"
+
+
+class InstalledOCRTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.network = patch("socket.socket.connect", side_effect=AssertionError("OCR attempted network access"))
+        cls.network.start()
+        cls.addClassCleanup(cls.network.stop)
+        cls.ocr = TinyOCR()
+
+    def test_installed_version_and_assets(self):
+        self.assertEqual(importlib.metadata.version("tinyocr-onnx"), "0.1.0")
+        self.assertEqual(tinyocr.__version__, "0.1.0")
+        assets = Path(tinyocr.__file__).parent / "assets"
+        expected = {
+            "PP-OCRv6_det_tiny.onnx": "f42c0fbd294d95eac1a550e131b277dac97462c8025fa4b6c3cec1b7894bd3d5",
+            "PP-OCRv6_rec_tiny.onnx": "38cd559cb4b24c5056592d981b13e086f9472db9b3c8968296f0d0c2b4a65531",
+        }
+        for filename, digest in expected.items():
+            self.assertEqual(hashlib.sha256((assets / filename).read_bytes()).hexdigest(), digest)
+        for module in (self.ocr._engine.text_det, self.ocr._engine.text_rec):
+            session = module.session.session
+            self.assertEqual(session.get_providers(), ["CPUExecutionProvider"])
+            self.assertEqual(session.get_session_options().intra_op_num_threads, 1)
+            self.assertEqual(session.get_session_options().inter_op_num_threads, 1)
+
+    def test_real_offline_ocr(self):
+        result = self.ocr(FIXTURES / "receipt.png")
+        self.assertEqual(result.text, "HELLO WORLD\nTOTAL 123.45")
+        self.assertEqual([r["text"] for r in result.lines], ["HELLO WORLD", "TOTAL 123.45"])
+        self.assertEqual([r["text"] for r in result.words], ["HELLO", "WORLD", "TOTAL", "123.45"])
+        for region in result.lines + result.words:
+            self.assertEqual(len(region["polygon"]), 4)
+            for x, y in region["polygon"]:
+                self.assertTrue(math.isfinite(x) and math.isfinite(y))
+                self.assertTrue(0 <= x <= 700 and 0 <= y <= 210)
+        self.assertEqual(json.loads(json.dumps(result.to_dict()))["text"], result.text)
+
+    def test_word_toggle_keeps_lines(self):
+        with_words = self.ocr(FIXTURES / "receipt.png")
+        without_words = self.ocr(FIXTURES / "receipt.png", words=False)
+        self.assertEqual(with_words.text, without_words.text)
+        self.assertEqual(with_words.lines, without_words.lines)
+        self.assertEqual(without_words.words, [])
+        self.assertEqual(self.ocr(FIXTURES / "receipt.png").words, with_words.words)
+
+    def test_blank(self):
+        self.assertEqual(self.ocr(FIXTURES / "blank.png").to_dict(), {"text": "", "lines": [], "words": []})
+
+    def test_missing_and_invalid_image(self):
+        with self.assertRaises(FileNotFoundError):
+            self.ocr(FIXTURES / "missing.png")
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "invalid.png"
+            path.write_text("not an image", encoding="utf-8")
+            with self.assertRaises(Exception):
+                self.ocr(path)
+
+    def test_cli_text_json_version_and_errors(self):
+        # The audit hook also forbids network access inside the CLI subprocess.
+        bootstrap = (
+            "import sys,runpy; "
+            "sys.addaudithook(lambda event,args: "
+            "(_ for _ in ()).throw(RuntimeError('network forbidden')) "
+            "if event == 'socket.connect' else None); "
+            "runpy.run_module('tinyocr',run_name='__main__')"
+        )
+        def cli(*args):
+            return subprocess.run([sys.executable, "-c", bootstrap, *map(str, args)],
+                                  capture_output=True, text=True, encoding="utf-8", timeout=60)
+        result = cli(FIXTURES / "receipt.png")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), "HELLO WORLD\nTOTAL 123.45")
+        result = cli(FIXTURES / "receipt.png", "--json", "--no-words")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        data = json.loads(result.stdout)
+        self.assertEqual(data["text"], "HELLO WORLD\nTOTAL 123.45")
+        self.assertEqual(data["words"], [])
+        self.assertEqual(cli("--version").stdout.strip(), "tinyocr-onnx 0.1.0")
+        result = cli(FIXTURES / "missing.png")
+        self.assertEqual(result.returncode, 2)
+        self.assertIn("does not exist", result.stderr)
+        self.assertNotIn("Traceback", result.stderr)
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "invalid.png"
+            path.write_text("not an image", encoding="utf-8")
+            result = cli(path)
+            self.assertEqual(result.returncode, 1)
+            self.assertNotIn("Traceback", result.stderr)
+
+    def test_console_entry_point(self):
+        executable = shutil.which("tinyocr")
+        self.assertIsNotNone(executable)
+        result = subprocess.run([executable, "--version"], capture_output=True, text=True, timeout=30)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), "tinyocr-onnx 0.1.0")
+
+
+if __name__ == "__main__":
+    unittest.main()