mathcraft-ocr 0.2.8__tar.gz → 0.2.9__tar.gz

{mathcraft_ocr-0.2.8/mathcraft_ocr.egg-info → mathcraft_ocr-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathcraft-ocr
-Version: 0.2.8
+Version: 0.2.9
 Summary: ONNX-only OCR runtime for mathematical documents
 Author: SakuraMathcraft
 License-Expression: GPL-3.0-only
@@ -21,21 +21,25 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Classifier: Topic :: Text Processing
-Requires-Python: >=3.10
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<3,>=1.26
-Requires-Dist: pillow<12,>=10
+Requires-Dist: numpy<3,>=2
+Requires-Dist: pillow<13,>=12
 Requires-Dist: opencv-python<5,>=4.10
 Requires-Dist: rapidocr==3.5.0
 Requires-Dist: transformers==4.55.4
 Requires-Dist: tokenizers==0.21.4
 Provides-Extra: cpu
-Requires-Dist: onnxruntime<1.26,>=1.19.2; python_version < "3.13" and extra == "cpu"
-Requires-Dist: onnxruntime<1.26,>=1.20; python_version >= "3.13" and extra == "cpu"
+Requires-Dist: onnxruntime<1.30,>=1.20; extra == "cpu"
 Provides-Extra: gpu
-Requires-Dist: onnxruntime-gpu<1.26,>=1.19.2; python_version < "3.13" and extra == "gpu"
-Requires-Dist: onnxruntime-gpu<1.26,>=1.20; python_version >= "3.13" and extra == "gpu"
+Requires-Dist: onnxruntime-gpu<1.30,>=1.27; extra == "gpu"
+Provides-Extra: gpu-cu12
+Requires-Dist: onnxruntime-gpu<1.27,>=1.21; extra == "gpu-cu12"
+Provides-Extra: directml
+Requires-Dist: onnxruntime-directml<1.30,>=1.20; platform_system == "Windows" and extra == "directml"
+Provides-Extra: openvino
+Requires-Dist: onnxruntime-openvino<1.30,>=1.20; (platform_system == "Windows" or platform_system == "Linux") and extra == "openvino"
 Provides-Extra: dev
 Requires-Dist: ruff>=0.8; extra == "dev"
 Requires-Dist: build>=1.2; extra == "dev"
@@ -76,9 +80,27 @@ GPU backend:
 pip install "mathcraft-ocr[gpu]"
 ```
 
-Install only one backend extra in a clean environment. `onnxruntime` and `onnxruntime-gpu` should not be mixed in the same environment.
+CUDA 12 backend:
 
-LaTeXSnipper's dependency wizard selects the ONNX Runtime GPU wheel line from the detected CUDA toolkit. CUDA 11.x uses the ONNX Runtime CUDA 11 package feed, CUDA 12.x uses the stable PyPI GPU wheels, and CUDA 13.x uses the ONNX Runtime CUDA 13 nightly feed. Static `mathcraft-ocr[gpu]` package metadata cannot inspect the local CUDA toolkit, so it keeps a broad stable PyPI range; CUDA 11.x users installing manually should use the CUDA 11 feed shown by the wizard.
+```powershell
+pip install "mathcraft-ocr[gpu-cu12]"
+```
+
+Windows DirectML backend:
+
+```powershell
+pip install "mathcraft-ocr[directml]"
+```
+
+Intel OpenVINO backend on Windows or Linux:
+
+```powershell
+pip install "mathcraft-ocr[openvino]"
+```
+
+Install only one backend extra in a clean environment. The CPU, CUDA/TensorRT, DirectML, and OpenVINO ONNX Runtime distributions must not be mixed in the same environment. The standard `onnxruntime` macOS wheel includes CoreML EP support.
+
+LaTeXSnipper's dependency wizard selects the ONNX Runtime GPU line from the detected CUDA toolkit: CUDA 11.x uses ONNX Runtime 1.20 from the official CUDA 11 feed, CUDA 12.x uses ONNX Runtime 1.21-1.26 from PyPI, and CUDA 13.x uses ONNX Runtime 1.27-1.29 from PyPI. The static `mathcraft-ocr[gpu]` extra follows the current PyPI default (CUDA 13 and Python 3.11+); use `gpu-cu12` for CUDA 12. CUDA 11 installations must also select the official CUDA 11 package feed, so LaTeXSnipper's dependency wizard is recommended for that configuration.
 
 ## Quick Start
 
@@ -190,9 +212,34 @@ Model artifacts are downloaded from the MathCraft-Models release assets declared
 
 `provider_preference` accepts:
 
-- `auto`: prefer CUDA when available and valid, otherwise CPU.
+- `auto`: prefer CUDA, then a platform accelerator, and finally CPU; TensorRT remains explicit because of its first-use engine build cost.
 - `cpu`: force CPU.
-- `gpu`: request CUDA-capable ONNX Runtime.
+- `gpu`: request the first available supported accelerator.
+- `cuda`: request CUDA.
+- `tensorrt` or `trt`: request TensorRT, followed by CUDA and CPU for unsupported nodes.
+- `directml` or `dml`: request DirectML.
+- `coreml`: request CoreML.
+- `openvino`: request OpenVINO.
+
+Advanced callers can pass an explicit ordered provider list and provider options:
+
+```python
+runtime = MathCraftRuntime(
+    providers=[
+        (
+            "TensorrtExecutionProvider",
+            {
+                "device_id": 0,
+                "trt_engine_cache_enable": True,
+                "trt_engine_cache_path": "./trt-cache",
+            },
+        ),
+        ("CUDAExecutionProvider", {"device_id": 0}),
+    ]
+)
+```
+
+`auto` deliberately prefers CUDA over TensorRT because TensorRT can spend substantial time building an engine on first use. Select `tensorrt` explicitly when its native runtime is installed; enable its engine cache for repeated startup performance.
 
 The actual provider is available on recognition results through the `provider` field. Doctor and warmup reports also expose `device_id`, `device_name`, `device_uuid`, and `device_verified` under `provider_info`. GPU sessions bind the reported `device_id` explicitly; `device_verified` becomes true only after the runtime confirms the device used by initialized inference sessions.
 

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/README_MATHCRAFT_OCR.md

@@ -30,9 +30,27 @@ GPU backend:
 pip install "mathcraft-ocr[gpu]"
 ```
 
-Install only one backend extra in a clean environment. `onnxruntime` and `onnxruntime-gpu` should not be mixed in the same environment.
+CUDA 12 backend:
 
-LaTeXSnipper's dependency wizard selects the ONNX Runtime GPU wheel line from the detected CUDA toolkit. CUDA 11.x uses the ONNX Runtime CUDA 11 package feed, CUDA 12.x uses the stable PyPI GPU wheels, and CUDA 13.x uses the ONNX Runtime CUDA 13 nightly feed. Static `mathcraft-ocr[gpu]` package metadata cannot inspect the local CUDA toolkit, so it keeps a broad stable PyPI range; CUDA 11.x users installing manually should use the CUDA 11 feed shown by the wizard.
+```powershell
+pip install "mathcraft-ocr[gpu-cu12]"
+```
+
+Windows DirectML backend:
+
+```powershell
+pip install "mathcraft-ocr[directml]"
+```
+
+Intel OpenVINO backend on Windows or Linux:
+
+```powershell
+pip install "mathcraft-ocr[openvino]"
+```
+
+Install only one backend extra in a clean environment. The CPU, CUDA/TensorRT, DirectML, and OpenVINO ONNX Runtime distributions must not be mixed in the same environment. The standard `onnxruntime` macOS wheel includes CoreML EP support.
+
+LaTeXSnipper's dependency wizard selects the ONNX Runtime GPU line from the detected CUDA toolkit: CUDA 11.x uses ONNX Runtime 1.20 from the official CUDA 11 feed, CUDA 12.x uses ONNX Runtime 1.21-1.26 from PyPI, and CUDA 13.x uses ONNX Runtime 1.27-1.29 from PyPI. The static `mathcraft-ocr[gpu]` extra follows the current PyPI default (CUDA 13 and Python 3.11+); use `gpu-cu12` for CUDA 12. CUDA 11 installations must also select the official CUDA 11 package feed, so LaTeXSnipper's dependency wizard is recommended for that configuration.
 
 ## Quick Start
 
@@ -144,9 +162,34 @@ Model artifacts are downloaded from the MathCraft-Models release assets declared
 
 `provider_preference` accepts:
 
-- `auto`: prefer CUDA when available and valid, otherwise CPU.
+- `auto`: prefer CUDA, then a platform accelerator, and finally CPU; TensorRT remains explicit because of its first-use engine build cost.
 - `cpu`: force CPU.
-- `gpu`: request CUDA-capable ONNX Runtime.
+- `gpu`: request the first available supported accelerator.
+- `cuda`: request CUDA.
+- `tensorrt` or `trt`: request TensorRT, followed by CUDA and CPU for unsupported nodes.
+- `directml` or `dml`: request DirectML.
+- `coreml`: request CoreML.
+- `openvino`: request OpenVINO.
+
+Advanced callers can pass an explicit ordered provider list and provider options:
+
+```python
+runtime = MathCraftRuntime(
+    providers=[
+        (
+            "TensorrtExecutionProvider",
+            {
+                "device_id": 0,
+                "trt_engine_cache_enable": True,
+                "trt_engine_cache_path": "./trt-cache",
+            },
+        ),
+        ("CUDAExecutionProvider", {"device_id": 0}),
+    ]
+)
+```
+
+`auto` deliberately prefers CUDA over TensorRT because TensorRT can spend substantial time building an engine on first use. Select `tensorrt` explicitly when its native runtime is installed; enable its engine cache for repeated startup performance.
 
 The actual provider is available on recognition results through the `provider` field. Doctor and warmup reports also expose `device_id`, `device_name`, `device_uuid`, and `device_verified` under `provider_info`. GPU sessions bind the reported `device_id` explicitly; `device_verified` becomes true only after the runtime confirms the device used by initialized inference sessions.
 

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/mathcraft_ocr/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.2.8"
+__version__ = "0.2.9"
 
 __all__ = [
     "DoctorReport",
@@ -12,6 +12,8 @@ __all__ = [
     "MathCraftRuntime",
     "MixedRecognitionResult",
     "OCRRegion",
+    "ProviderInfo",
+    "ProviderSpec",
     "__version__",
     "run_doctor",
 ]
@@ -32,6 +34,10 @@ def __getattr__(name: str) -> object:
         from . import doctor
 
         return getattr(doctor, name)
+    if name in {"ProviderInfo", "ProviderSpec"}:
+        from . import providers
+
+        return getattr(providers, name)
     if name == "MathCraftError":
         from .errors import MathCraftError
 

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/mathcraft_ocr/adapters/common.py

@@ -6,7 +6,7 @@ import importlib
 from functools import lru_cache
 from pathlib import Path
 
-from ..providers import GPU_PROVIDER_NAMES, ProviderInfo
+from ..providers import ACCELERATOR_PROVIDER_NAMES, ProviderInfo
 
 
 ProviderOptions = tuple[tuple[str, str], ...]
@@ -17,12 +17,14 @@ def _ort():
     return importlib.import_module("onnxruntime")
 
 
-def session_providers(provider_info: ProviderInfo) -> list[str | tuple[str, dict[str, int]]]:
+def session_providers(provider_info: ProviderInfo) -> list[str | tuple[str, dict[str, object]]]:
+    if provider_info.provider_specs:
+        return [spec.as_ort_provider() for spec in provider_info.provider_specs]
     available = list(provider_info.available_providers)
     active = provider_info.active_provider
-    if active and active in GPU_PROVIDER_NAMES and "CPUExecutionProvider" in available:
+    if active and active in ACCELERATOR_PROVIDER_NAMES and "CPUExecutionProvider" in available:
         return [(active, {"device_id": int(provider_info.device_id or 0)}), "CPUExecutionProvider"]
-    if active and active in GPU_PROVIDER_NAMES:
+    if active and active in ACCELERATOR_PROVIDER_NAMES:
         return [(active, {"device_id": int(provider_info.device_id or 0)})]
     if "CPUExecutionProvider" in available:
         return ["CPUExecutionProvider"]
@@ -44,15 +46,34 @@ def _create_session_cached(model_path: str, providers: tuple[ProviderConfig, ...
         (name, {key: value for key, value in options}) if options else name
         for name, options in providers
     ]
-    return ort.InferenceSession(
-        model_path,
-        providers=configured,
-        enable_fallback=False,
-    )
+    kwargs = {
+        "providers": configured,
+        "enable_fallback": False,
+    }
+    session_options = _session_options(ort, providers)
+    if session_options is not None:
+        kwargs["sess_options"] = session_options
+    return ort.InferenceSession(model_path, **kwargs)
+
+
+def _session_options(ort, providers: tuple[ProviderConfig, ...]):
+    create_options = getattr(ort, "SessionOptions", None)
+    if not callable(create_options):
+        return None
+    session_options = create_options()
+    session_options.log_severity_level = 4
+    names = {name for name, _options in providers}
+    if "DmlExecutionProvider" not in names:
+        return session_options
+    session_options.enable_mem_pattern = False
+    execution_mode = getattr(getattr(ort, "ExecutionMode", None), "ORT_SEQUENTIAL", None)
+    if execution_mode is not None:
+        session_options.execution_mode = execution_mode
+    return session_options
 
 
 def _freeze_provider_config(
-    providers: list[str | tuple[str, dict[str, int]]],
+    providers: list[str | tuple[str, dict[str, object]]],
 ) -> tuple[ProviderConfig, ...]:
     frozen: list[ProviderConfig] = []
     for item in providers:
@@ -82,12 +103,12 @@ def validate_session_provider(
     actual = list(session.get_providers() or [])
     active = str(active_provider or "")
     if not actual or actual[0] != active:
-        provider_kind = "ONNX GPU provider" if active in GPU_PROVIDER_NAMES else "ONNX provider"
+        provider_kind = "ONNX accelerator provider" if active in ACCELERATOR_PROVIDER_NAMES else "ONNX provider"
         raise RuntimeError(
             f"requested {provider_kind} {active or '<none>'}, "
             f"but {runtime_name} session providers are {actual}"
         )
-    if active in GPU_PROVIDER_NAMES:
+    if active in {"CUDAExecutionProvider", "TensorrtExecutionProvider", "DmlExecutionProvider"}:
         get_options = getattr(session, "get_provider_options", None)
         if callable(get_options):
             options_by_provider = get_options() or {}

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/mathcraft_ocr/adapters/text_recognizer.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from functools import lru_cache
 from pathlib import Path
 
@@ -10,7 +11,11 @@ from rapidocr import EngineType, LangRec, ModelType, OCRVersion
 from rapidocr.ch_ppocr_rec import TextRecInput, TextRecognizer
 from rapidocr.utils.typings import TaskType
 
-from .common import validate_session_provider
+from .common import create_session
+from ..providers import ProviderInfo
+
+
+logging.getLogger("RapidOCR").setLevel(logging.WARNING)
 
 
 class _Config(dict):
@@ -56,26 +61,13 @@ def recognize_pp_text_lines(
 
 def _create_pp_text_recognizer(model_dir: Path, provider_info) -> TextRecognizer:
     model_dir = model_dir.resolve()
-    active_provider = str(getattr(provider_info, "active_provider", "") or "")
-    device_id = int(getattr(provider_info, "device_id", 0) or 0)
-    use_cuda = active_provider in {"CUDAExecutionProvider", "TensorrtExecutionProvider"}
-    use_dml = active_provider == "DmlExecutionProvider"
-    return _create_pp_text_recognizer_cached(
-        str(model_dir),
-        active_provider,
-        device_id,
-        use_cuda,
-        use_dml,
-    )
+    return _create_pp_text_recognizer_cached(str(model_dir), provider_info)
 
 
 @lru_cache(maxsize=8)
 def _create_pp_text_recognizer_cached(
     model_dir: str,
-    active_provider: str,
-    device_id: int,
-    use_cuda: bool,
-    use_dml: bool,
+    provider_info: ProviderInfo,
 ) -> TextRecognizer:
     model_dir = Path(model_dir)
     model_candidates = sorted(model_dir.glob("**/*rec*.onnx"))
@@ -89,6 +81,7 @@ def _create_pp_text_recognizer_cached(
     is_server = "server" in model_name or "server" in model_dir.name
     is_v5 = "v5" in model_name or "v5" in model_dir.name
     is_english = dict_path.name == "en_dict.txt"
+    session = create_session(model_path, provider_info)
     config = _Config({
         "engine_type": EngineType.ONNXRUNTIME,
         "lang_type": LangRec.EN if is_english else LangRec.CH,
@@ -101,51 +94,10 @@ def _create_pp_text_recognizer_cached(
         "rec_img_shape": [3, 48, 320],
         "rec_batch_num": 6,
         "font_path": None,
-        "engine_cfg": {
-            "intra_op_num_threads": -1,
-            "inter_op_num_threads": -1,
-            "enable_cpu_mem_arena": False,
-            "cpu_ep_cfg": {"arena_extend_strategy": "kSameAsRequested"},
-            "use_cuda": use_cuda,
-            "cuda_ep_cfg": {
-                "device_id": device_id,
-                "arena_extend_strategy": "kNextPowerOfTwo",
-                "cudnn_conv_algo_search": "EXHAUSTIVE",
-                "do_copy_in_default_stream": True,
-            },
-            "use_dml": use_dml,
-            "dm_ep_cfg": {"device_id": device_id},
-            "use_cann": False,
-            "cann_ep_cfg": {
-                "device_id": 0,
-                "arena_extend_strategy": "kNextPowerOfTwo",
-                "npu_mem_limit": 21474836480,
-                "op_select_impl_mode": "high_performance",
-                "optypelist_for_implmode": "Gelu",
-                "enable_cann_graph": True,
-            },
-        },
+        "session": session,
+        "engine_cfg": {},
     })
-    recognizer = TextRecognizer(config)
-    _enforce_strict_provider(recognizer, active_provider, device_id)
-    return recognizer
-
-
-def _enforce_strict_provider(
-    recognizer: TextRecognizer,
-    active_provider: str,
-    device_id: int = 0,
-) -> None:
-    engine = getattr(recognizer, "session", None)
-    session = getattr(engine, "session", None)
-    if session is None:
-        raise RuntimeError("RapidOCR did not expose its ONNX Runtime session")
-    validate_session_provider(
-        session,
-        active_provider,
-        device_id,
-        runtime_name="RapidOCR",
-    )
+    return TextRecognizer(config)
 
 
 def clear_text_recognizer_cache() -> None:

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/mathcraft_ocr/cli.py

@@ -16,6 +16,9 @@ from .serialization import (
 )
 
 
+_PROVIDER_HELP = "auto, cpu, gpu, cuda, tensorrt, directml, coreml, or openvino"
+
+
 def _resolve_ocr_output_path(args: argparse.Namespace) -> Path | None:
     output = str(getattr(args, "output", "") or "").strip()
     output_dir = str(getattr(args, "output_dir", "") or "").strip()
@@ -45,22 +48,22 @@ def build_parser() -> argparse.ArgumentParser:
     models_sub.add_parser("check")
 
     doctor = sub.add_parser("doctor")
-    doctor.add_argument("--provider", default="auto")
+    doctor.add_argument("--provider", default="auto", help=_PROVIDER_HELP)
 
     warmup = sub.add_parser("warmup")
     warmup.add_argument("--profile", default="formula")
-    warmup.add_argument("--provider", default="auto")
+    warmup.add_argument("--provider", default="auto", help=_PROVIDER_HELP)
 
     ocr = sub.add_parser("ocr")
     ocr.add_argument("image")
     ocr.add_argument("--profile", choices=("formula", "text", "mixed"), default="mixed")
-    ocr.add_argument("--provider", default="auto")
+    ocr.add_argument("--provider", default="auto", help=_PROVIDER_HELP)
     ocr.add_argument("--output", "-o", default="")
     ocr.add_argument("--output-dir", default="")
     ocr.add_argument("--json", action="store_true", dest="as_json")
 
     worker = sub.add_parser("worker")
-    worker.add_argument("--provider", default="auto")
+    worker.add_argument("--provider", default="auto", help=_PROVIDER_HELP)
     return parser
 
 

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/mathcraft_ocr/doctor.py

@@ -3,12 +3,13 @@
 from __future__ import annotations
 
 import sys
+from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
 from .cache import inspect_manifest_roots, resolve_model_roots, resolve_user_models_dir
 from .manifest import Manifest, load_manifest
-from .providers import ProviderInfo, detect_providers
+from .providers import ProviderInfo, ProviderRequest, detect_providers
 
 
 @dataclass(frozen=True)
@@ -28,6 +29,7 @@ def run_doctor(
     bundled_models_dir: str | Path | None = None,
     manifest: Manifest | None = None,
     provider_preference: str = "auto",
+    providers: Sequence[ProviderRequest] | None = None,
     include_optional: bool = True,
 ) -> DoctorReport:
     manifest_obj = manifest or load_manifest()
@@ -36,7 +38,7 @@ def run_doctor(
     states = inspect_manifest_roots(
         model_roots, manifest_obj, include_optional=include_optional
     )
-    provider_info = detect_providers(prefer=provider_preference)
+    provider_info = detect_providers(prefer=provider_preference, providers=providers)
     return DoctorReport(
         python_executable=sys.executable,
         cache_dir=cache_root,

mathcraft_ocr-0.2.9/mathcraft_ocr/providers.py

@@ -0,0 +1,279 @@
+# coding: utf-8
+
+from __future__ import annotations
+
+import importlib
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, replace
+
+from .devices import confirm_device_identity, resolve_device_identity
+from .errors import ProviderError
+
+
+MAIN_PROVIDER_NAMES = (
+    "CPUExecutionProvider",
+    "CUDAExecutionProvider",
+    "TensorrtExecutionProvider",
+    "DmlExecutionProvider",
+    "CoreMLExecutionProvider",
+    "OpenVINOExecutionProvider",
+)
+
+ACCELERATOR_PROVIDER_NAMES = tuple(
+    name for name in MAIN_PROVIDER_NAMES if name != "CPUExecutionProvider"
+)
+
+# Kept as a compatibility alias for integrations importing the old name.
+GPU_PROVIDER_NAMES = ACCELERATOR_PROVIDER_NAMES
+
+_PROVIDER_ALIASES = {
+    "cpu": "CPUExecutionProvider",
+    "cuda": "CUDAExecutionProvider",
+    "tensorrt": "TensorrtExecutionProvider",
+    "trt": "TensorrtExecutionProvider",
+    "directml": "DmlExecutionProvider",
+    "dml": "DmlExecutionProvider",
+    "coreml": "CoreMLExecutionProvider",
+    "openvino": "OpenVINOExecutionProvider",
+}
+
+_AUTO_PRIORITY = (
+    "CUDAExecutionProvider",
+    "DmlExecutionProvider",
+    "CoreMLExecutionProvider",
+    "OpenVINOExecutionProvider",
+    "CPUExecutionProvider",
+)
+
+_ACCELERATOR_PRIORITY = (
+    "CUDAExecutionProvider",
+    "TensorrtExecutionProvider",
+    "DmlExecutionProvider",
+    "CoreMLExecutionProvider",
+    "OpenVINOExecutionProvider",
+)
+
+ProviderRequest = str | tuple[str, Mapping[str, object]]
+
+
+@dataclass(frozen=True)
+class ProviderSpec:
+    name: str
+    options: tuple[tuple[str, str], ...] = ()
+
+    def as_ort_provider(self) -> str | tuple[str, dict[str, str]]:
+        if not self.options:
+            return self.name
+        return self.name, dict(self.options)
+
+
+@dataclass(frozen=True)
+class ProviderInfo:
+    available_providers: tuple[str, ...]
+    active_provider: str | None
+    device: str
+    gpu_requested: bool
+    gpu_runtime_ok: bool
+    device_id: int | None = None
+    device_name: str = ""
+    device_uuid: str = ""
+    device_verified: bool = False
+    provider_specs: tuple[ProviderSpec, ...] = ()
+
+    @property
+    def use_cuda(self) -> bool:
+        return self.active_provider in {"CUDAExecutionProvider", "TensorrtExecutionProvider"}
+
+    @property
+    def use_dml(self) -> bool:
+        return self.active_provider == "DmlExecutionProvider"
+
+    @property
+    def use_tensorrt(self) -> bool:
+        return self.active_provider == "TensorrtExecutionProvider"
+
+    @property
+    def use_coreml(self) -> bool:
+        return self.active_provider == "CoreMLExecutionProvider"
+
+    @property
+    def use_openvino(self) -> bool:
+        return self.active_provider == "OpenVINOExecutionProvider"
+
+    @property
+    def requested_providers(self) -> tuple[str, ...]:
+        if self.provider_specs:
+            return tuple(spec.name for spec in self.provider_specs)
+        return (self.active_provider,) if self.active_provider else ()
+
+
+def detect_providers(
+    prefer: str = "auto",
+    providers: Sequence[ProviderRequest] | None = None,
+) -> ProviderInfo:
+    prefer_norm = (prefer or "auto").strip().lower()
+    if providers is None and prefer_norm not in {"auto", "cpu", "gpu", *_PROVIDER_ALIASES}:
+        raise ProviderError(f"unsupported provider preference: {prefer}")
+    try:
+        ort = importlib.import_module("onnxruntime")
+    except Exception as exc:  # pragma: no cover - import environment dependent
+        raise ProviderError(f"failed to import onnxruntime: {exc}") from exc
+
+    get_available_providers = getattr(ort, "get_available_providers", None)
+    if not callable(get_available_providers):
+        origin = getattr(ort, "__file__", None) or "<namespace package>"
+        raise ProviderError(
+            "onnxruntime dependency is incomplete: missing get_available_providers "
+            f"(origin={origin})"
+        )
+
+    try:
+        available = tuple(get_available_providers())
+    except Exception as exc:  # pragma: no cover - runtime environment dependent
+        raise ProviderError(f"failed to query ONNX providers: {exc}") from exc
+
+    specs = _resolve_provider_specs(prefer_norm, providers, available)
+    active = specs[0].name
+    accelerated = active in ACCELERATOR_PROVIDER_NAMES
+    device = (
+        "gpu"
+        if active in {"CUDAExecutionProvider", "TensorrtExecutionProvider", "DmlExecutionProvider"}
+        else "accelerator"
+        if accelerated
+        else "cpu"
+    )
+    return _provider_info(
+        available_providers=available,
+        active_provider=active,
+        device=device,
+        gpu_requested=accelerated,
+        gpu_runtime_ok=accelerated,
+        provider_specs=specs,
+    )
+
+
+def _resolve_provider_specs(
+    prefer: str,
+    providers: Sequence[ProviderRequest] | None,
+    available: tuple[str, ...],
+) -> tuple[ProviderSpec, ...]:
+    if providers is not None:
+        if isinstance(providers, (str, bytes)) or not providers:
+            raise ProviderError("providers must be a non-empty sequence")
+        specs = tuple(_normalize_provider_request(item) for item in providers)
+        _ensure_available(specs, available)
+        return specs
+
+    if prefer == "auto":
+        active = next((name for name in _AUTO_PRIORITY if name in available), None)
+        if active is None:
+            raise ProviderError(f"no supported ONNX execution provider is available: {available}")
+        return _default_provider_chain(active, available)
+
+    if prefer == "gpu":
+        active = next((name for name in _ACCELERATOR_PRIORITY if name in available), None)
+        if active is None:
+            raise ProviderError(f"GPU provider was requested but none is available: {available}")
+        return _default_provider_chain(active, available)
+
+    active = _PROVIDER_ALIASES[prefer]
+    if active not in available:
+        raise ProviderError(f"requested ONNX provider {active} is unavailable: {available}")
+    return _default_provider_chain(active, available)
+
+
+def _normalize_provider_request(request: ProviderRequest) -> ProviderSpec:
+    if isinstance(request, str):
+        raw_name = request
+        options: Mapping[str, object] = {}
+    elif isinstance(request, tuple) and len(request) == 2 and isinstance(request[1], Mapping):
+        raw_name, options = request
+    else:
+        raise ProviderError(f"invalid provider specification: {request!r}")
+    name = _canonical_provider_name(str(raw_name))
+    if name not in MAIN_PROVIDER_NAMES:
+        raise ProviderError(f"unsupported ONNX provider: {raw_name}")
+    frozen_options = tuple(sorted((str(key), str(value)) for key, value in options.items()))
+    return ProviderSpec(name=name, options=frozen_options)
+
+
+def _canonical_provider_name(name: str) -> str:
+    stripped = name.strip()
+    return _PROVIDER_ALIASES.get(stripped.lower(), stripped)
+
+
+def _ensure_available(specs: tuple[ProviderSpec, ...], available: tuple[str, ...]) -> None:
+    unavailable = tuple(spec.name for spec in specs if spec.name not in available)
+    if unavailable:
+        raise ProviderError(
+            f"requested ONNX providers are unavailable: {unavailable}; available={available}"
+        )
+
+
+def _default_provider_chain(active: str, available: tuple[str, ...]) -> tuple[ProviderSpec, ...]:
+    names = [active]
+    if active == "TensorrtExecutionProvider" and "CUDAExecutionProvider" in available:
+        names.append("CUDAExecutionProvider")
+    if active != "CPUExecutionProvider" and "CPUExecutionProvider" in available:
+        names.append("CPUExecutionProvider")
+    return tuple(ProviderSpec(name=name, options=_default_options(name)) for name in names)
+
+
+def _default_options(name: str) -> tuple[tuple[str, str], ...]:
+    if name in {"CUDAExecutionProvider", "TensorrtExecutionProvider", "DmlExecutionProvider"}:
+        return (("device_id", "0"),)
+    return ()
+
+
+def _provider_info(
+    *,
+    available_providers: tuple[str, ...],
+    active_provider: str,
+    device: str,
+    gpu_requested: bool,
+    gpu_runtime_ok: bool,
+    provider_specs: tuple[ProviderSpec, ...] = (),
+) -> ProviderInfo:
+    active_spec = next((spec for spec in provider_specs if spec.name == active_provider), None)
+    active_options = dict(active_spec.options) if active_spec else {}
+    device_id = (
+        int(active_options.get("device_id", 0))
+        if active_provider in {"CUDAExecutionProvider", "TensorrtExecutionProvider", "DmlExecutionProvider"}
+        else None
+    )
+    identity = resolve_device_identity(active_provider, device_id)
+    return ProviderInfo(
+        available_providers=available_providers,
+        active_provider=active_provider,
+        device=device,
+        gpu_requested=gpu_requested,
+        gpu_runtime_ok=gpu_runtime_ok,
+        device_id=identity.device_id,
+        device_name=identity.name,
+        device_uuid=identity.uuid,
+        device_verified=identity.verified,
+        provider_specs=provider_specs,
+    )
+
+
+def confirm_provider_device(provider_info: ProviderInfo) -> ProviderInfo:
+    identity = confirm_device_identity(provider_info.active_provider, provider_info.device_id)
+    return replace(
+        provider_info,
+        device_id=identity.device_id,
+        device_name=identity.name,
+        device_uuid=identity.uuid,
+        device_verified=identity.verified,
+    )
+
+
+__all__ = [
+    "ACCELERATOR_PROVIDER_NAMES",
+    "GPU_PROVIDER_NAMES",
+    "MAIN_PROVIDER_NAMES",
+    "ProviderInfo",
+    "ProviderRequest",
+    "ProviderSpec",
+    "confirm_provider_device",
+    "detect_providers",
+]

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/mathcraft_ocr/runtime.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 import sys
@@ -56,7 +57,7 @@ from .profiles import (
     TEXT_DETECTOR_ID,
     TEXT_RECOGNIZER_ID,
 )
-from .providers import ProviderInfo, confirm_provider_device
+from .providers import ProviderInfo, ProviderRequest, confirm_provider_device
 from .results import Box4P, FormulaRecognitionResult, MathCraftBlock, MixedRecognitionResult, OCRRegion
 
 
@@ -98,6 +99,7 @@ class MathCraftRuntime:
         *,
         cache_dir: str | Path | None = None,
         provider_preference: str = "auto",
+        providers: Sequence[ProviderRequest] | None = None,
         manifest: Manifest | None = None,
         bundled_models_dir: str | Path | None = None,
         auto_download: bool = True,
@@ -106,6 +108,7 @@ class MathCraftRuntime:
         self.bundled_models_dir = Path(bundled_models_dir) if bundled_models_dir else None
         self.model_roots = resolve_model_roots(cache_dir, bundled_models_dir)
         self.provider_preference = provider_preference
+        self.providers = tuple(providers) if providers is not None else None
         self.manifest = manifest or load_manifest()
         self.auto_download = auto_download
         self._warmup_cache: dict[str, WarmupPlan] = {}
@@ -131,6 +134,7 @@ class MathCraftRuntime:
             bundled_models_dir=self.bundled_models_dir,
             manifest=self.manifest,
             provider_preference=self.provider_preference,
+            providers=self.providers,
         )
 
     def doctor(self) -> DoctorReport:

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/mathcraft_ocr/serialization.py

@@ -67,6 +67,7 @@ def mixed_result_to_json(result: MixedRecognitionResult) -> dict:
 def provider_info_to_json(provider_info) -> dict:
     return {
         "available_providers": list(provider_info.available_providers),
+        "requested_providers": list(provider_info.requested_providers),
         "active_provider": provider_info.active_provider,
         "device": provider_info.device,
         "device_id": provider_info.device_id,
@@ -77,6 +78,9 @@ def provider_info_to_json(provider_info) -> dict:
         "gpu_runtime_ok": provider_info.gpu_runtime_ok,
         "use_cuda": provider_info.use_cuda,
         "use_dml": provider_info.use_dml,
+        "use_tensorrt": provider_info.use_tensorrt,
+        "use_coreml": provider_info.use_coreml,
+        "use_openvino": provider_info.use_openvino,
     }
 
 

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/mathcraft_ocr/worker.py

@@ -12,6 +12,9 @@ from .runtime import FORMULA_MAX_NEW_TOKENS, MathCraftRuntime
 from .serialization import doctor_report_to_json, formula_result_to_json, mixed_result_to_json, warmup_plan_to_json
 
 
+_PROVIDER_HELP = "auto, cpu, gpu, cuda, tensorrt, directml, coreml, or openvino"
+
+
 class MathCraftWorker:
     def __init__(
         self,
@@ -113,7 +116,7 @@ def serve_jsonl(
 
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="mathcraft-worker")
-    parser.add_argument("--provider", default="auto")
+    parser.add_argument("--provider", default="auto", help=_PROVIDER_HELP)
     return parser
 
 

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9/mathcraft_ocr.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathcraft-ocr
-Version: 0.2.8
+Version: 0.2.9
 Summary: ONNX-only OCR runtime for mathematical documents
 Author: SakuraMathcraft
 License-Expression: GPL-3.0-only
@@ -21,21 +21,25 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Classifier: Topic :: Text Processing
-Requires-Python: >=3.10
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<3,>=1.26
-Requires-Dist: pillow<12,>=10
+Requires-Dist: numpy<3,>=2
+Requires-Dist: pillow<13,>=12
 Requires-Dist: opencv-python<5,>=4.10
 Requires-Dist: rapidocr==3.5.0
 Requires-Dist: transformers==4.55.4
 Requires-Dist: tokenizers==0.21.4
 Provides-Extra: cpu
-Requires-Dist: onnxruntime<1.26,>=1.19.2; python_version < "3.13" and extra == "cpu"
-Requires-Dist: onnxruntime<1.26,>=1.20; python_version >= "3.13" and extra == "cpu"
+Requires-Dist: onnxruntime<1.30,>=1.20; extra == "cpu"
 Provides-Extra: gpu
-Requires-Dist: onnxruntime-gpu<1.26,>=1.19.2; python_version < "3.13" and extra == "gpu"
-Requires-Dist: onnxruntime-gpu<1.26,>=1.20; python_version >= "3.13" and extra == "gpu"
+Requires-Dist: onnxruntime-gpu<1.30,>=1.27; extra == "gpu"
+Provides-Extra: gpu-cu12
+Requires-Dist: onnxruntime-gpu<1.27,>=1.21; extra == "gpu-cu12"
+Provides-Extra: directml
+Requires-Dist: onnxruntime-directml<1.30,>=1.20; platform_system == "Windows" and extra == "directml"
+Provides-Extra: openvino
+Requires-Dist: onnxruntime-openvino<1.30,>=1.20; (platform_system == "Windows" or platform_system == "Linux") and extra == "openvino"
 Provides-Extra: dev
 Requires-Dist: ruff>=0.8; extra == "dev"
 Requires-Dist: build>=1.2; extra == "dev"
@@ -76,9 +80,27 @@ GPU backend:
 pip install "mathcraft-ocr[gpu]"
 ```
 
-Install only one backend extra in a clean environment. `onnxruntime` and `onnxruntime-gpu` should not be mixed in the same environment.
+CUDA 12 backend:
 
-LaTeXSnipper's dependency wizard selects the ONNX Runtime GPU wheel line from the detected CUDA toolkit. CUDA 11.x uses the ONNX Runtime CUDA 11 package feed, CUDA 12.x uses the stable PyPI GPU wheels, and CUDA 13.x uses the ONNX Runtime CUDA 13 nightly feed. Static `mathcraft-ocr[gpu]` package metadata cannot inspect the local CUDA toolkit, so it keeps a broad stable PyPI range; CUDA 11.x users installing manually should use the CUDA 11 feed shown by the wizard.
+```powershell
+pip install "mathcraft-ocr[gpu-cu12]"
+```
+
+Windows DirectML backend:
+
+```powershell
+pip install "mathcraft-ocr[directml]"
+```
+
+Intel OpenVINO backend on Windows or Linux:
+
+```powershell
+pip install "mathcraft-ocr[openvino]"
+```
+
+Install only one backend extra in a clean environment. The CPU, CUDA/TensorRT, DirectML, and OpenVINO ONNX Runtime distributions must not be mixed in the same environment. The standard `onnxruntime` macOS wheel includes CoreML EP support.
+
+LaTeXSnipper's dependency wizard selects the ONNX Runtime GPU line from the detected CUDA toolkit: CUDA 11.x uses ONNX Runtime 1.20 from the official CUDA 11 feed, CUDA 12.x uses ONNX Runtime 1.21-1.26 from PyPI, and CUDA 13.x uses ONNX Runtime 1.27-1.29 from PyPI. The static `mathcraft-ocr[gpu]` extra follows the current PyPI default (CUDA 13 and Python 3.11+); use `gpu-cu12` for CUDA 12. CUDA 11 installations must also select the official CUDA 11 package feed, so LaTeXSnipper's dependency wizard is recommended for that configuration.
 
 ## Quick Start
 
@@ -190,9 +212,34 @@ Model artifacts are downloaded from the MathCraft-Models release assets declared
 
 `provider_preference` accepts:
 
-- `auto`: prefer CUDA when available and valid, otherwise CPU.
+- `auto`: prefer CUDA, then a platform accelerator, and finally CPU; TensorRT remains explicit because of its first-use engine build cost.
 - `cpu`: force CPU.
-- `gpu`: request CUDA-capable ONNX Runtime.
+- `gpu`: request the first available supported accelerator.
+- `cuda`: request CUDA.
+- `tensorrt` or `trt`: request TensorRT, followed by CUDA and CPU for unsupported nodes.
+- `directml` or `dml`: request DirectML.
+- `coreml`: request CoreML.
+- `openvino`: request OpenVINO.
+
+Advanced callers can pass an explicit ordered provider list and provider options:
+
+```python
+runtime = MathCraftRuntime(
+    providers=[
+        (
+            "TensorrtExecutionProvider",
+            {
+                "device_id": 0,
+                "trt_engine_cache_enable": True,
+                "trt_engine_cache_path": "./trt-cache",
+            },
+        ),
+        ("CUDAExecutionProvider", {"device_id": 0}),
+    ]
+)
+```
+
+`auto` deliberately prefers CUDA over TensorRT because TensorRT can spend substantial time building an engine on first use. Select `tensorrt` explicitly when its native runtime is installed; enable its engine cache for repeated startup performance.
 
 The actual provider is available on recognition results through the `provider` field. Doctor and warmup reports also expose `device_id`, `device_name`, `device_uuid`, and `device_verified` under `provider_info`. GPU sessions bind the reported `device_id` explicitly; `device_verified` becomes true only after the runtime confirms the device used by initialized inference sessions.
 

mathcraft_ocr-0.2.9/mathcraft_ocr.egg-info/requires.txt

@@ -0,0 +1,33 @@
+numpy<3,>=2
+pillow<13,>=12
+opencv-python<5,>=4.10
+rapidocr==3.5.0
+transformers==4.55.4
+tokenizers==0.21.4
+
+[cpu]
+onnxruntime<1.30,>=1.20
+
+[dev]
+ruff>=0.8
+build>=1.2
+twine>=5.0
+
+[directml]
+
+[directml:platform_system == "Windows"]
+onnxruntime-directml<1.30,>=1.20
+
+[gpu]
+onnxruntime-gpu<1.30,>=1.27
+
+[gpu-cu12]
+onnxruntime-gpu<1.27,>=1.21
+
+[openvino]
+
+[openvino:platform_system == "Windows" or platform_system == "Linux"]
+onnxruntime-openvino<1.30,>=1.20
+
+[pandoc]
+pypandoc>=1.15

{mathcraft_ocr-0.2.8 → mathcraft_ocr-0.2.9}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mathcraft-ocr"
-version = "0.2.8"
+version = "0.2.9"
 description = "ONNX-only OCR runtime for mathematical documents"
 readme = "README_MATHCRAFT_OCR.md"
-requires-python = ">=3.10"
+requires-python = ">=3.10,<3.14"
 license = "GPL-3.0-only"
 license-files = ["LICENSE"]
 authors = [
@@ -37,8 +37,8 @@ classifiers = [
   "Topic :: Text Processing"
 ]
 dependencies = [
-  "numpy>=1.26,<3",
-  "pillow>=10,<12",
+  "numpy>=2,<3",
+  "pillow>=12,<13",
   "opencv-python>=4.10,<5",
   "rapidocr==3.5.0",
   "transformers==4.55.4",
@@ -47,12 +47,19 @@ dependencies = [
 
 [project.optional-dependencies]
 cpu = [
-  "onnxruntime>=1.19.2,<1.26; python_version < '3.13'",
-  "onnxruntime>=1.20,<1.26; python_version >= '3.13'",
+  "onnxruntime>=1.20,<1.30",
 ]
 gpu = [
-  "onnxruntime-gpu>=1.19.2,<1.26; python_version < '3.13'",
-  "onnxruntime-gpu>=1.20,<1.26; python_version >= '3.13'",
+  "onnxruntime-gpu>=1.27,<1.30",
+]
+gpu-cu12 = [
+  "onnxruntime-gpu>=1.21,<1.27",
+]
+directml = [
+  "onnxruntime-directml>=1.20,<1.30; platform_system == 'Windows'",
+]
+openvino = [
+  "onnxruntime-openvino>=1.20,<1.30; platform_system == 'Windows' or platform_system == 'Linux'",
 ]
 dev = [
   "ruff>=0.8",

mathcraft_ocr-0.2.8/mathcraft_ocr/providers.py

@@ -1,128 +0,0 @@
-# coding: utf-8
-
-from __future__ import annotations
-
-import importlib
-from dataclasses import dataclass, replace
-
-from .devices import confirm_device_identity, resolve_device_identity
-from .errors import ProviderError
-
-
-GPU_PROVIDER_NAMES = (
-    "CUDAExecutionProvider",
-    "TensorrtExecutionProvider",
-    "DmlExecutionProvider",
-)
-
-
-@dataclass(frozen=True)
-class ProviderInfo:
-    available_providers: tuple[str, ...]
-    active_provider: str | None
-    device: str
-    gpu_requested: bool
-    gpu_runtime_ok: bool
-    device_id: int | None = None
-    device_name: str = ""
-    device_uuid: str = ""
-    device_verified: bool = False
-
-    @property
-    def use_cuda(self) -> bool:
-        return self.active_provider in {"CUDAExecutionProvider", "TensorrtExecutionProvider"}
-
-    @property
-    def use_dml(self) -> bool:
-        return self.active_provider == "DmlExecutionProvider"
-
-
-def detect_providers(prefer: str = "auto") -> ProviderInfo:
-    prefer_norm = (prefer or "auto").strip().lower()
-    if prefer_norm not in {"auto", "cpu", "gpu"}:
-        raise ProviderError(f"unsupported provider preference: {prefer}")
-    try:
-        ort = importlib.import_module("onnxruntime")
-    except Exception as exc:  # pragma: no cover - import environment dependent
-        raise ProviderError(f"failed to import onnxruntime: {exc}") from exc
-
-    get_available_providers = getattr(ort, "get_available_providers", None)
-    if not callable(get_available_providers):
-        origin = getattr(ort, "__file__", None) or "<namespace package>"
-        raise ProviderError(
-            "onnxruntime dependency is incomplete: missing get_available_providers "
-            f"(origin={origin})"
-        )
-
-    try:
-        available = tuple(get_available_providers())
-    except Exception as exc:  # pragma: no cover - runtime environment dependent
-        raise ProviderError(f"failed to query ONNX providers: {exc}") from exc
-
-    gpu_candidates = tuple(name for name in GPU_PROVIDER_NAMES if name in available)
-    gpu_visible = bool(gpu_candidates)
-    if prefer_norm == "cpu":
-        if "CPUExecutionProvider" not in available:
-            raise ProviderError(f"CPUExecutionProvider unavailable: {available}")
-        return _provider_info(
-            available_providers=available,
-            active_provider="CPUExecutionProvider",
-            device="cpu",
-            gpu_requested=False,
-            gpu_runtime_ok=False,
-        )
-    if gpu_visible:
-        return _provider_info(
-            available_providers=available,
-            active_provider=gpu_candidates[0],
-            device="gpu",
-            gpu_requested=True,
-            gpu_runtime_ok=True,
-        )
-    if prefer_norm == "gpu":
-        raise ProviderError(
-            f"GPU provider was requested but none is available: {available}"
-        )
-    if "CPUExecutionProvider" not in available:
-        raise ProviderError(f"no supported ONNX execution provider is available: {available}")
-    return _provider_info(
-        available_providers=available,
-        active_provider="CPUExecutionProvider",
-        device="cpu",
-        gpu_requested=False,
-        gpu_runtime_ok=False,
-    )
-
-
-def _provider_info(
-    *,
-    available_providers: tuple[str, ...],
-    active_provider: str,
-    device: str,
-    gpu_requested: bool,
-    gpu_runtime_ok: bool,
-) -> ProviderInfo:
-    device_id = 0 if active_provider in GPU_PROVIDER_NAMES else None
-    identity = resolve_device_identity(active_provider, device_id)
-    return ProviderInfo(
-        available_providers=available_providers,
-        active_provider=active_provider,
-        device=device,
-        gpu_requested=gpu_requested,
-        gpu_runtime_ok=gpu_runtime_ok,
-        device_id=identity.device_id,
-        device_name=identity.name,
-        device_uuid=identity.uuid,
-        device_verified=identity.verified,
-    )
-
-
-def confirm_provider_device(provider_info: ProviderInfo) -> ProviderInfo:
-    identity = confirm_device_identity(provider_info.active_provider, provider_info.device_id)
-    return replace(
-        provider_info,
-        device_id=identity.device_id,
-        device_name=identity.name,
-        device_uuid=identity.uuid,
-        device_verified=identity.verified,
-    )

mathcraft_ocr-0.2.8/mathcraft_ocr.egg-info/requires.txt

@@ -1,30 +0,0 @@
-numpy<3,>=1.26
-pillow<12,>=10
-opencv-python<5,>=4.10
-rapidocr==3.5.0
-transformers==4.55.4
-tokenizers==0.21.4
-
-[cpu]
-
-[cpu:python_version < "3.13"]
-onnxruntime<1.26,>=1.19.2
-
-[cpu:python_version >= "3.13"]
-onnxruntime<1.26,>=1.20
-
-[dev]
-ruff>=0.8
-build>=1.2
-twine>=5.0
-
-[gpu]
-
-[gpu:python_version < "3.13"]
-onnxruntime-gpu<1.26,>=1.19.2
-
-[gpu:python_version >= "3.13"]
-onnxruntime-gpu<1.26,>=1.20
-
-[pandoc]
-pypandoc>=1.15