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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathcraft-ocr
-Version: 0.2.7
+Version: 0.2.8
 Summary: ONNX-only OCR runtime for mathematical documents
 Author: SakuraMathcraft
 License-Expression: GPL-3.0-only
@@ -194,7 +194,7 @@ Model artifacts are downloaded from the MathCraft-Models release assets declared
 - `cpu`: force CPU.
 - `gpu`: request CUDA-capable ONNX Runtime.
 
-The actual provider is available on results through the `provider` field.
+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.
 
 ## Development
 

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

@@ -148,7 +148,7 @@ Model artifacts are downloaded from the MathCraft-Models release assets declared
 - `cpu`: force CPU.
 - `gpu`: request CUDA-capable ONNX Runtime.
 
-The actual provider is available on results through the `provider` field.
+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.
 
 ## Development
 

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.2.7"
+__version__ = "0.2.8"
 
 __all__ = [
     "DoctorReport",

mathcraft_ocr-0.2.8/mathcraft_ocr/adapters/common.py

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+from __future__ import annotations
+
+import importlib
+from functools import lru_cache
+from pathlib import Path
+
+from ..providers import GPU_PROVIDER_NAMES, ProviderInfo
+
+
+ProviderOptions = tuple[tuple[str, str], ...]
+ProviderConfig = tuple[str, ProviderOptions]
+
+
+def _ort():
+    return importlib.import_module("onnxruntime")
+
+
+def session_providers(provider_info: ProviderInfo) -> list[str | tuple[str, dict[str, int]]]:
+    available = list(provider_info.available_providers)
+    active = provider_info.active_provider
+    if active and active in GPU_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:
+        return [(active, {"device_id": int(provider_info.device_id or 0)})]
+    if "CPUExecutionProvider" in available:
+        return ["CPUExecutionProvider"]
+    return available
+
+
+def create_session(model_path: str | Path, provider_info: ProviderInfo):
+    model_path = str(Path(model_path).resolve())
+    provider_config = _freeze_provider_config(session_providers(provider_info))
+    session = _create_session_cached(model_path, provider_config)
+    enforce_session_provider(session, provider_info)
+    return session
+
+
+@lru_cache(maxsize=16)
+def _create_session_cached(model_path: str, providers: tuple[ProviderConfig, ...]):
+    ort = _ort()
+    configured = [
+        (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,
+    )
+
+
+def _freeze_provider_config(
+    providers: list[str | tuple[str, dict[str, int]]],
+) -> tuple[ProviderConfig, ...]:
+    frozen: list[ProviderConfig] = []
+    for item in providers:
+        if isinstance(item, str):
+            frozen.append((item, ()))
+            continue
+        name, options = item
+        frozen.append((name, tuple(sorted((str(key), str(value)) for key, value in options.items()))))
+    return tuple(frozen)
+
+
+def enforce_session_provider(session, provider_info: ProviderInfo) -> None:
+    validate_session_provider(
+        session,
+        str(provider_info.active_provider or ""),
+        int(provider_info.device_id or 0),
+    )
+
+
+def validate_session_provider(
+    session,
+    active_provider: str,
+    device_id: int = 0,
+    *,
+    runtime_name: str = "ONNX Runtime",
+) -> None:
+    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"
+        raise RuntimeError(
+            f"requested {provider_kind} {active or '<none>'}, "
+            f"but {runtime_name} session providers are {actual}"
+        )
+    if active in GPU_PROVIDER_NAMES:
+        get_options = getattr(session, "get_provider_options", None)
+        if callable(get_options):
+            options_by_provider = get_options() or {}
+            active_options = options_by_provider.get(active, {}) if isinstance(options_by_provider, dict) else {}
+            actual_device_id = active_options.get("device_id") if isinstance(active_options, dict) else None
+            if actual_device_id not in (None, "") and int(actual_device_id) != int(device_id):
+                raise RuntimeError(
+                    f"requested ONNX provider {active} device_id={int(device_id)}, "
+                    f"but {runtime_name} session uses device_id={actual_device_id}"
+                )
+    disable_fallback = getattr(session, "disable_fallback", None)
+    if not callable(disable_fallback):
+        raise RuntimeError(f"{runtime_name} session cannot disable provider fallback")
+    disable_fallback()
+
+
+def clear_session_cache() -> None:
+    _create_session_cached.cache_clear()

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

@@ -10,6 +10,8 @@ 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
+
 
 class _Config(dict):
     def __init__(self, *args, **kwargs):
@@ -55,11 +57,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,
     )
@@ -69,6 +73,7 @@ def _create_pp_text_recognizer(model_dir: Path, provider_info) -> TextRecognizer
 def _create_pp_text_recognizer_cached(
     model_dir: str,
     active_provider: str,
+    device_id: int,
     use_cuda: bool,
     use_dml: bool,
 ) -> TextRecognizer:
@@ -103,13 +108,13 @@ def _create_pp_text_recognizer_cached(
             "cpu_ep_cfg": {"arena_extend_strategy": "kSameAsRequested"},
             "use_cuda": use_cuda,
             "cuda_ep_cfg": {
-                "device_id": 0,
+                "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": None,
+            "dm_ep_cfg": {"device_id": device_id},
             "use_cann": False,
             "cann_ep_cfg": {
                 "device_id": 0,
@@ -122,25 +127,25 @@ def _create_pp_text_recognizer_cached(
         },
     })
     recognizer = TextRecognizer(config)
-    _enforce_strict_provider(recognizer, active_provider)
+    _enforce_strict_provider(recognizer, active_provider, device_id)
     return recognizer
 
 
-def _enforce_strict_provider(recognizer: TextRecognizer, active_provider: str) -> None:
+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")
-    actual = list(session.get_providers() or [])
-    if not active_provider or not actual or actual[0] != active_provider:
-        raise RuntimeError(
-            f"requested ONNX provider {active_provider or '<none>'}, "
-            f"but RapidOCR session providers are {actual}"
-        )
-    disable_fallback = getattr(session, "disable_fallback", None)
-    if not callable(disable_fallback):
-        raise RuntimeError("RapidOCR ONNX Runtime session cannot disable provider fallback")
-    disable_fallback()
+    validate_session_provider(
+        session,
+        active_provider,
+        device_id,
+        runtime_name="RapidOCR",
+    )
 
 
 def clear_text_recognizer_cache() -> None:

mathcraft_ocr-0.2.8/mathcraft_ocr/devices.py

@@ -0,0 +1,360 @@
+# coding: utf-8
+
+from __future__ import annotations
+
+import ctypes
+from dataclasses import dataclass
+import os
+import platform
+from pathlib import Path
+import subprocess
+import sys
+import uuid
+
+
+@dataclass(frozen=True)
+class DeviceIdentity:
+    device_id: int | None = None
+    name: str = ""
+    uuid: str = ""
+    verified: bool = False
+
+
+@dataclass(frozen=True)
+class NvidiaDevice:
+    index: int
+    name: str
+    uuid: str
+    total_memory_mb: int = 0
+    free_memory_mb: int = 0
+    driver_version: str = ""
+
+
+@dataclass(frozen=True)
+class DxgiAdapter:
+    index: int
+    name: str
+    luid: str
+    dedicated_memory_mb: int = 0
+
+
+def resolve_device_identity(provider: str | None, device_id: int | None) -> DeviceIdentity:
+    active = str(provider or "")
+    if active == "CPUExecutionProvider":
+        return DeviceIdentity(name=_cpu_name(), verified=True)
+    selected_id = max(0, int(device_id or 0))
+    if active in {"CUDAExecutionProvider", "TensorrtExecutionProvider"}:
+        device = select_nvidia_device(query_nvidia_devices(), selected_id)
+        if device is None:
+            return DeviceIdentity(device_id=selected_id)
+        return DeviceIdentity(device_id=selected_id, name=device.name, uuid=device.uuid)
+    if active == "DmlExecutionProvider":
+        adapters = query_dxgi_adapters()
+        adapter = next((item for item in adapters if item.index == selected_id), None)
+        if adapter is None:
+            return DeviceIdentity(device_id=selected_id)
+        return DeviceIdentity(device_id=selected_id, name=adapter.name, uuid=adapter.luid)
+    return DeviceIdentity()
+
+
+def confirm_device_identity(provider: str | None, device_id: int | None) -> DeviceIdentity:
+    active = str(provider or "")
+    selected = resolve_device_identity(active, device_id)
+    if active in {"CUDAExecutionProvider", "TensorrtExecutionProvider"}:
+        active_uuids = query_nvidia_process_gpu_uuids()
+        if not active_uuids:
+            return selected
+        devices = query_nvidia_devices()
+        matches = [item for item in devices if item.uuid.lower() in active_uuids]
+        if len(matches) == 1:
+            device = matches[0]
+            return DeviceIdentity(
+                device_id=max(0, int(device_id or 0)),
+                name=device.name,
+                uuid=device.uuid,
+                verified=True,
+            )
+        if selected.uuid and selected.uuid.lower() in active_uuids:
+            return DeviceIdentity(
+                device_id=selected.device_id,
+                name=selected.name,
+                uuid=selected.uuid,
+                verified=True,
+            )
+        return DeviceIdentity(device_id=max(0, int(device_id or 0)))
+    if active == "DmlExecutionProvider":
+        return DeviceIdentity(
+            device_id=selected.device_id,
+            name=selected.name,
+            uuid=selected.uuid,
+            verified=bool(selected.name),
+        )
+    return selected
+
+
+def query_nvidia_devices() -> tuple[NvidiaDevice, ...]:
+    try:
+        proc = subprocess.run(
+            [
+                "nvidia-smi",
+                "--query-gpu=index,name,uuid,memory.total,memory.free,driver_version",
+                "--format=csv,noheader,nounits",
+            ],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=3.0,
+        )
+    except Exception:
+        return ()
+    if proc.returncode != 0:
+        return ()
+    devices: list[NvidiaDevice] = []
+    for raw in proc.stdout.splitlines():
+        parts = [part.strip() for part in raw.split(",")]
+        if len(parts) < 6:
+            continue
+        try:
+            index = int(parts[0])
+        except (TypeError, ValueError):
+            continue
+        devices.append(
+            NvidiaDevice(
+                index=index,
+                name=parts[1],
+                uuid=parts[2],
+                total_memory_mb=_safe_int(parts[3]),
+                free_memory_mb=_safe_int(parts[4]),
+                driver_version=parts[5],
+            )
+        )
+    return tuple(devices)
+
+
+def query_nvidia_process_gpu_uuids(pid: int | None = None) -> frozenset[str]:
+    expected_pid = int(pid or os.getpid())
+    try:
+        proc = subprocess.run(
+            [
+                "nvidia-smi",
+                "--query-compute-apps=pid,gpu_uuid",
+                "--format=csv,noheader,nounits",
+            ],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=3.0,
+        )
+    except Exception:
+        return frozenset()
+    if proc.returncode != 0:
+        return frozenset()
+    matches: set[str] = set()
+    for raw in proc.stdout.splitlines():
+        parts = [part.strip() for part in raw.split(",", 1)]
+        if len(parts) != 2:
+            continue
+        try:
+            process_id = int(parts[0])
+        except (TypeError, ValueError):
+            continue
+        if process_id == expected_pid and parts[1]:
+            matches.add(parts[1].lower())
+    return frozenset(matches)
+
+
+def select_nvidia_device(
+    devices: tuple[NvidiaDevice, ...],
+    logical_device_id: int,
+    visible_devices: str | None = None,
+) -> NvidiaDevice | None:
+    if logical_device_id < 0:
+        return None
+    raw_visible = os.environ.get("CUDA_VISIBLE_DEVICES", "") if visible_devices is None else visible_devices
+    tokens = [token.strip() for token in raw_visible.split(",") if token.strip()]
+    if tokens:
+        if logical_device_id >= len(tokens):
+            return None
+        token = tokens[logical_device_id]
+        if token == "-1":
+            return None
+        if token.isdigit():
+            physical_index = int(token)
+            return next((item for item in devices if item.index == physical_index), None)
+        normalized = token.lower()
+        return next(
+            (
+                item
+                for item in devices
+                if item.uuid.lower() == normalized or item.uuid.lower().startswith(normalized)
+            ),
+            None,
+        )
+    return next((item for item in devices if item.index == logical_device_id), None)
+
+
+def query_dxgi_adapters() -> tuple[DxgiAdapter, ...]:
+    if os.name != "nt":
+        return ()
+    try:
+        return _query_dxgi_adapters_windows()
+    except Exception:
+        return ()
+
+
+def _query_dxgi_adapters_windows() -> tuple[DxgiAdapter, ...]:
+    from ctypes import wintypes
+
+    class _Guid(ctypes.Structure):
+        _fields_ = [
+            ("Data1", wintypes.DWORD),
+            ("Data2", wintypes.WORD),
+            ("Data3", wintypes.WORD),
+            ("Data4", ctypes.c_ubyte * 8),
+        ]
+
+        @classmethod
+        def parse(cls, value: str):
+            return cls.from_buffer_copy(uuid.UUID(value).bytes_le)
+
+    class _Luid(ctypes.Structure):
+        _fields_ = [("LowPart", wintypes.DWORD), ("HighPart", wintypes.LONG)]
+
+    class _AdapterDesc1(ctypes.Structure):
+        _fields_ = [
+            ("Description", ctypes.c_wchar * 128),
+            ("VendorId", wintypes.UINT),
+            ("DeviceId", wintypes.UINT),
+            ("SubSysId", wintypes.UINT),
+            ("Revision", wintypes.UINT),
+            ("DedicatedVideoMemory", ctypes.c_size_t),
+            ("DedicatedSystemMemory", ctypes.c_size_t),
+            ("SharedSystemMemory", ctypes.c_size_t),
+            ("AdapterLuid", _Luid),
+            ("Flags", wintypes.UINT),
+        ]
+
+    factory = ctypes.c_void_p()
+    create_factory = ctypes.windll.dxgi.CreateDXGIFactory1
+    create_factory.argtypes = [ctypes.POINTER(_Guid), ctypes.POINTER(ctypes.c_void_p)]
+    create_factory.restype = ctypes.c_long
+    iid_factory1 = _Guid.parse("770aae78-f26f-4dba-a829-253c83d1b387")
+    result = create_factory(ctypes.byref(iid_factory1), ctypes.byref(factory))
+    if result < 0 or not factory.value:
+        return ()
+
+    def _method(pointer: ctypes.c_void_p, index: int, prototype):
+        table = ctypes.cast(pointer, ctypes.POINTER(ctypes.POINTER(ctypes.c_void_p))).contents
+        return prototype(table[index])
+
+    release_proto = ctypes.WINFUNCTYPE(wintypes.ULONG, ctypes.c_void_p)
+    enum_proto = ctypes.WINFUNCTYPE(
+        ctypes.c_long,
+        ctypes.c_void_p,
+        wintypes.UINT,
+        ctypes.POINTER(ctypes.c_void_p),
+    )
+    get_desc_proto = ctypes.WINFUNCTYPE(
+        ctypes.c_long,
+        ctypes.c_void_p,
+        ctypes.POINTER(_AdapterDesc1),
+    )
+    release_factory = _method(factory, 2, release_proto)
+    enum_adapters = _method(factory, 12, enum_proto)
+    adapters: list[DxgiAdapter] = []
+    try:
+        index = 0
+        while True:
+            adapter = ctypes.c_void_p()
+            result = enum_adapters(factory, index, ctypes.byref(adapter))
+            if result != 0 or not adapter.value:
+                break
+            release_adapter = _method(adapter, 2, release_proto)
+            try:
+                desc = _AdapterDesc1()
+                get_desc = _method(adapter, 10, get_desc_proto)
+                if get_desc(adapter, ctypes.byref(desc)) >= 0:
+                    high = int(desc.AdapterLuid.HighPart) & 0xFFFFFFFF
+                    low = int(desc.AdapterLuid.LowPart) & 0xFFFFFFFF
+                    adapters.append(
+                        DxgiAdapter(
+                            index=index,
+                            name=str(desc.Description).strip(),
+                            luid=f"LUID-{high:08X}-{low:08X}",
+                            dedicated_memory_mb=int(desc.DedicatedVideoMemory // (1024 * 1024)),
+                        )
+                    )
+            finally:
+                release_adapter(adapter)
+            index += 1
+    finally:
+        release_factory(factory)
+    return tuple(adapters)
+
+
+def _cpu_name() -> str:
+    if os.name == "nt":
+        try:
+            import winreg
+
+            with winreg.OpenKey(
+                winreg.HKEY_LOCAL_MACHINE,
+                r"HARDWARE\DESCRIPTION\System\CentralProcessor\0",
+            ) as key:
+                value, _ = winreg.QueryValueEx(key, "ProcessorNameString")
+            name = str(value or "").strip()
+            if name:
+                return name
+        except Exception:
+            pass
+    name = str(platform.processor() or "").strip()
+    if name:
+        return name
+    if os.name == "nt":
+        return str(os.environ.get("PROCESSOR_IDENTIFIER", "") or "").strip()
+    if sys.platform == "darwin":
+        try:
+            proc = subprocess.run(
+                ["sysctl", "-n", "machdep.cpu.brand_string"],
+                check=False,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=2.0,
+            )
+            if proc.returncode == 0 and proc.stdout.strip():
+                return proc.stdout.strip()
+        except Exception:
+            return ""
+    try:
+        for raw in Path("/proc/cpuinfo").read_text(encoding="utf-8", errors="ignore").splitlines():
+            if raw.lower().startswith("model name"):
+                return raw.split(":", 1)[-1].strip()
+    except Exception:
+        pass
+    return ""
+
+
+def _safe_int(value: str) -> int:
+    try:
+        return int(float(str(value).strip().replace(",", "")))
+    except Exception:
+        return 0
+
+
+__all__ = [
+    "DeviceIdentity",
+    "DxgiAdapter",
+    "NvidiaDevice",
+    "confirm_device_identity",
+    "query_dxgi_adapters",
+    "query_nvidia_devices",
+    "query_nvidia_process_gpu_uuids",
+    "resolve_device_identity",
+    "select_nvidia_device",
+]

{mathcraft_ocr-0.2.7 → mathcraft_ocr-0.2.8}/mathcraft_ocr/hardware.py

@@ -10,6 +10,7 @@ import os
 import subprocess
 import sys
 
+from .devices import query_dxgi_adapters, query_nvidia_devices, select_nvidia_device
 from .providers import GPU_PROVIDER_NAMES, ProviderInfo
 
 
@@ -24,11 +25,25 @@ class HardwareInfo:
     gpu_driver_version: str = ""
 
 
-@lru_cache(maxsize=1)
-def detect_hardware_info() -> HardwareInfo:
+@lru_cache(maxsize=8)
+def detect_hardware_info(provider_info: ProviderInfo | None = None) -> HardwareInfo:
     total_mb, free_mb = _memory_status()
-    gpu_name, gpu_total_mb, gpu_free_mb, gpu_driver = _query_nvidia_smi()
-    if not gpu_name:
+    gpu_name = ""
+    gpu_total_mb = 0
+    gpu_free_mb = 0
+    gpu_driver = ""
+    active = str(getattr(provider_info, "active_provider", "") or "")
+    device_id = int(getattr(provider_info, "device_id", 0) or 0)
+    if active in {"CUDAExecutionProvider", "TensorrtExecutionProvider"}:
+        gpu_name, gpu_total_mb, gpu_free_mb, gpu_driver = _query_nvidia_smi(device_id)
+    elif active == "DmlExecutionProvider":
+        adapter = next((item for item in query_dxgi_adapters() if item.index == device_id), None)
+        if adapter is not None:
+            gpu_name = adapter.name
+            gpu_total_mb = adapter.dedicated_memory_mb
+    elif provider_info is None:
+        gpu_name, gpu_total_mb, gpu_free_mb, gpu_driver = _query_nvidia_smi(0)
+    if provider_info is None and not gpu_name:
         gpu_name, gpu_total_mb, gpu_driver = _query_windows_video_controller()
     return HardwareInfo(
         logical_processors=max(1, int(os.cpu_count() or 1)),
@@ -148,30 +163,16 @@ def choose_rec_batch_num(
     return 4
 
 
-def _query_nvidia_smi() -> tuple[str, int, int, str]:
-    try:
-        proc = subprocess.run(
-            [
-                "nvidia-smi",
-                "--query-gpu=name,memory.total,memory.free,driver_version",
-                "--format=csv,noheader,nounits",
-            ],
-            check=False,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=2.0,
-        )
-    except Exception:
+def _query_nvidia_smi(device_id: int = 0) -> tuple[str, int, int, str]:
+    device = select_nvidia_device(query_nvidia_devices(), device_id)
+    if device is None:
         return "", 0, 0, ""
-    if proc.returncode != 0:
-        return "", 0, 0, ""
-    line = next((item.strip() for item in proc.stdout.splitlines() if item.strip()), "")
-    parts = [part.strip() for part in line.split(",")]
-    if len(parts) < 4:
-        return "", 0, 0, ""
-    return parts[0], _safe_int(parts[1]), _safe_int(parts[2]), parts[3]
+    return (
+        device.name,
+        device.total_memory_mb,
+        device.free_memory_mb,
+        device.driver_version,
+    )
 
 
 def _query_windows_video_controller() -> tuple[str, int, str]:

{mathcraft_ocr-0.2.7 → mathcraft_ocr-0.2.8}/mathcraft_ocr/providers.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 import importlib
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 
+from .devices import confirm_device_identity, resolve_device_identity
 from .errors import ProviderError
 
 
@@ -22,6 +23,10 @@ class ProviderInfo:
     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:
@@ -59,7 +64,7 @@ def detect_providers(prefer: str = "auto") -> ProviderInfo:
     if prefer_norm == "cpu":
         if "CPUExecutionProvider" not in available:
             raise ProviderError(f"CPUExecutionProvider unavailable: {available}")
-        return ProviderInfo(
+        return _provider_info(
             available_providers=available,
             active_provider="CPUExecutionProvider",
             device="cpu",
@@ -67,7 +72,7 @@ def detect_providers(prefer: str = "auto") -> ProviderInfo:
             gpu_runtime_ok=False,
         )
     if gpu_visible:
-        return ProviderInfo(
+        return _provider_info(
             available_providers=available,
             active_provider=gpu_candidates[0],
             device="gpu",
@@ -80,10 +85,44 @@ def detect_providers(prefer: str = "auto") -> ProviderInfo:
         )
     if "CPUExecutionProvider" not in available:
         raise ProviderError(f"no supported ONNX execution provider is available: {available}")
-    return ProviderInfo(
+    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.7 → mathcraft_ocr-0.2.8}/mathcraft_ocr/runtime.py

@@ -56,7 +56,7 @@ from .profiles import (
     TEXT_DETECTOR_ID,
     TEXT_RECOGNIZER_ID,
 )
-from .providers import ProviderInfo
+from .providers import ProviderInfo, confirm_provider_device
 from .results import Box4P, FormulaRecognitionResult, MathCraftBlock, MixedRecognitionResult, OCRRegion
 
 
@@ -618,13 +618,16 @@ class MathCraftRuntime:
                     except Exception as repair_exc:
                         exc = repair_exc
                 component_statuses.append(WarmupComponentStatus(model_id=model_id, ready=False, detail=str(exc)))
+        provider_info = report.provider_info
+        if any(item.ready for item in component_statuses):
+            provider_info = confirm_provider_device(provider_info)
         plan = WarmupPlan(
             profile=profile,
             required_models=model_ids,
             missing_models=tuple(missing),
             unsupported_models=tuple(unsupported),
             component_statuses=tuple(component_statuses),
-            provider_info=report.provider_info,
+            provider_info=provider_info,
             ready=not missing
             and not unsupported
             and all(item.ready for item in component_statuses),
@@ -639,13 +642,15 @@ class MathCraftRuntime:
             (
                 str(provider_info.device or ""),
                 str(provider_info.active_provider or ""),
+                str(provider_info.device_id),
+                str(provider_info.device_uuid or ""),
                 str(provider_info.gpu_runtime_ok),
             )
         )
         cached = self._rec_batch_cache.get(key)
         if cached:
             return cached
-        batch = choose_rec_batch_num(provider_info, detect_hardware_info())
+        batch = choose_rec_batch_num(provider_info, detect_hardware_info(provider_info))
         self._rec_batch_cache[key] = batch
         return batch
 

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

@@ -69,6 +69,10 @@ def provider_info_to_json(provider_info) -> dict:
         "available_providers": list(provider_info.available_providers),
         "active_provider": provider_info.active_provider,
         "device": provider_info.device,
+        "device_id": provider_info.device_id,
+        "device_name": provider_info.device_name,
+        "device_uuid": provider_info.device_uuid,
+        "device_verified": provider_info.device_verified,
         "gpu_requested": provider_info.gpu_requested,
         "gpu_runtime_ok": provider_info.gpu_runtime_ok,
         "use_cuda": provider_info.use_cuda,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathcraft-ocr
-Version: 0.2.7
+Version: 0.2.8
 Summary: ONNX-only OCR runtime for mathematical documents
 Author: SakuraMathcraft
 License-Expression: GPL-3.0-only
@@ -194,7 +194,7 @@ Model artifacts are downloaded from the MathCraft-Models release assets declared
 - `cpu`: force CPU.
 - `gpu`: request CUDA-capable ONNX Runtime.
 
-The actual provider is available on results through the `provider` field.
+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.
 
 ## Development
 

{mathcraft_ocr-0.2.7 → mathcraft_ocr-0.2.8}/mathcraft_ocr.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ mathcraft_ocr/api.py
 mathcraft_ocr/cache.py
 mathcraft_ocr/cli.py
 mathcraft_ocr/debug_blocks.py
+mathcraft_ocr/devices.py
 mathcraft_ocr/doctor.py
 mathcraft_ocr/downloader.py
 mathcraft_ocr/error_patterns.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mathcraft-ocr"
-version = "0.2.7"
+version = "0.2.8"
 description = "ONNX-only OCR runtime for mathematical documents"
 readme = "README_MATHCRAFT_OCR.md"
 requires-python = ">=3.10"

mathcraft_ocr-0.2.7/mathcraft_ocr/adapters/common.py

@@ -1,54 +0,0 @@
-# coding: utf-8
-
-from __future__ import annotations
-
-import importlib
-from functools import lru_cache
-from pathlib import Path
-
-from ..providers import GPU_PROVIDER_NAMES, ProviderInfo
-
-
-def _ort():
-    return importlib.import_module("onnxruntime")
-
-
-def session_providers(provider_info: ProviderInfo) -> list[str]:
-    available = list(provider_info.available_providers)
-    active = provider_info.active_provider
-    if active and active in GPU_PROVIDER_NAMES and "CPUExecutionProvider" in available:
-        return [active, "CPUExecutionProvider"]
-    if "CPUExecutionProvider" in available:
-        return ["CPUExecutionProvider"]
-    return available
-
-
-def create_session(model_path: str | Path, provider_info: ProviderInfo):
-    model_path = str(Path(model_path).resolve())
-    providers = tuple(session_providers(provider_info))
-    session = _create_session_cached(model_path, providers)
-    actual = list(session.get_providers() or [])
-    active = provider_info.active_provider
-    if active and active in GPU_PROVIDER_NAMES and active not in actual:
-        raise RuntimeError(
-            f"requested ONNX GPU provider {active}, but session providers are {actual}"
-        )
-    disable_fallback = getattr(session, "disable_fallback", None)
-    if not callable(disable_fallback):
-        raise RuntimeError("ONNX Runtime session cannot disable provider fallback")
-    disable_fallback()
-    return session
-
-
-@lru_cache(maxsize=16)
-def _create_session_cached(model_path: str, providers: tuple[str, ...]):
-    ort = _ort()
-    return ort.InferenceSession(
-        model_path,
-        providers=list(providers),
-        enable_fallback=False,
-    )
-
-
-def clear_session_cache() -> None:
-    _create_session_cached.cache_clear()