classifyre-cli 0.4.115__tar.gz → 0.4.116__tar.gz

classifyre_cli-0.4.116/.turbo/turbo-build.log

@@ -0,0 +1,3 @@
+$ uv sync
+Resolved 309 packages in 395ms
+Checked 51 packages in 4ms

{classifyre_cli-0.4.115 → classifyre_cli-0.4.116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: classifyre-cli
-Version: 0.4.115
+Version: 0.4.116
 Summary: Classifyre CLI — scan and classify unstructured data sources
 License: MIT
 Keywords: data,ingestion,metadata,pii,secrets,unstructured

{classifyre_cli-0.4.115 → classifyre_cli-0.4.116}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classifyre/cli",
-  "version": "0.4.115",
+  "version": "0.4.116",
   "private": true,
   "scripts": {
     "build": "uv sync",

{classifyre_cli-0.4.115 → classifyre_cli-0.4.116}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "classifyre-cli"
-version = "0.4.115"
+version = "0.4.116"
 description = "Classifyre CLI — scan and classify unstructured data sources"
 readme = "README.md"
 requires-python = ">=3.12"

{classifyre_cli-0.4.115 → classifyre_cli-0.4.116}/src/main.py

@@ -8,10 +8,20 @@ import sys
 from pathlib import Path
 from typing import Any, cast
 
-from .outputs import create_output_sink
-from .sources import get_source, list_available_sources
-from .sources.dropbox.auth import add_dropbox_auth_arguments, run_dropbox_auth_command
-from .utils.validation import validate_input, validate_test_connection
+# Must run before anything that imports torch (docling does, transitively via
+# the source and parser modules below): torch reads this configuration at
+# import time, so a later call would have no effect. See torch_runtime.
+from .utils.torch_runtime import configure_torch_runtime
+
+configure_torch_runtime()
+
+from .outputs import create_output_sink  # noqa: E402
+from .sources import get_source, list_available_sources  # noqa: E402
+from .sources.dropbox.auth import (  # noqa: E402
+    add_dropbox_auth_arguments,
+    run_dropbox_auth_command,
+)
+from .utils.validation import validate_input, validate_test_connection  # noqa: E402
 
 logger = logging.getLogger(__name__)
 _SURROGATE_RE = re.compile(r"[\ud800-\udfff]")

classifyre_cli-0.4.116/src/utils/torch_runtime.py

@@ -0,0 +1,60 @@
+"""Torch runtime configuration applied before torch is ever imported.
+
+Docling's OCR models run under torch, and torch.compile's inductor backend
+generates C++ and shells out to a compiler *at scan time*. That is a poor fit
+for how this CLI is deployed, in two independent ways:
+
+1. It needs a working C++ toolchain on the machine running the scan. Neither
+   the desktop bundle nor a slim container image promises one.
+2. Inductor builds the compiler command line without quoting its paths, so any
+   path containing a space breaks it. The desktop venv lives under
+   ``~/Library/Application Support/…``, which produces exactly that:
+
+       clang++: error: no such file or directory:
+         'Support/Classifyre/python-runtime/…/torch/lib'
+
+   Observed on a real desktop install: 167 compile errors and 33 OCR
+   extractions that returned no text at all, silently costing coverage on
+   every image and scanned document in the corpus.
+
+Docling falls back to eager execution when compilation fails, so the failure is
+not always fatal — it is just expensive. Measured on one 600x200 PNG with warm
+models: **58.5s compiling and failing, 24.9s with compilation disabled**, for
+identical extracted text. The compile step is pure loss here.
+
+So it is off by default. An explicitly set ``TORCH_COMPILE_DISABLE`` is always
+honoured, so a deployment that has a toolchain, space-free paths, and a
+measured reason to want inductor can turn it back on.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+# torch 2.13 reads TORCH_COMPILE_DISABLE. The older TORCHDYNAMO_DISABLE is
+# still widely cited but no longer flips torch._dynamo.config.disable, so
+# setting that one instead would look correct and do nothing.
+_DISABLE_ENV = "TORCH_COMPILE_DISABLE"
+
+
+def configure_torch_runtime(env: dict[str, str] | None = None) -> bool:
+    """Disable torch.compile unless the environment already decided.
+
+    Must be called before torch (or anything importing it, such as docling) is
+    imported: torch reads this variable at import time.
+
+    :returns: True when this call disabled compilation, False when the
+        environment already set a value and was left alone.
+    """
+    target = env if env is not None else os.environ
+
+    existing = target.get(_DISABLE_ENV)
+    if existing is not None and existing.strip() != "":
+        logger.debug("Leaving %s=%s as configured by the environment", _DISABLE_ENV, existing)
+        return False
+
+    target[_DISABLE_ENV] = "1"
+    return True

classifyre_cli-0.4.116/tests/test_torch_runtime.py

@@ -0,0 +1,80 @@
+"""torch.compile must be off before torch is imported.
+
+The failure this prevents is quiet rather than loud: docling falls back to
+eager execution when inductor cannot compile, so scans keep running and only
+the clock and the coverage suffer. On a desktop install that meant 167 compile
+errors and 33 OCR extractions returning no text, and a measured 58.5s versus
+24.9s on one image for identical output.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+from src.utils.torch_runtime import configure_torch_runtime
+
+REPO_CLI_ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_disables_compilation_when_unset() -> None:
+    env: dict[str, str] = {}
+
+    assert configure_torch_runtime(env) is True
+    assert env["TORCH_COMPILE_DISABLE"] == "1"
+
+
+def test_uses_the_variable_this_torch_actually_reads() -> None:
+    """TORCHDYNAMO_DISABLE is the widely-cited name and does nothing in 2.13.
+
+    Setting the wrong variable looks correct in review and in the environment
+    dump, and silently leaves compilation on.
+    """
+    env: dict[str, str] = {}
+    configure_torch_runtime(env)
+
+    assert "TORCH_COMPILE_DISABLE" in env
+    assert "TORCHDYNAMO_DISABLE" not in env
+
+
+def test_an_explicit_setting_is_left_alone() -> None:
+    """A deployment with a toolchain and space-free paths may want inductor."""
+    for configured in ("0", "1", "false"):
+        env = {"TORCH_COMPILE_DISABLE": configured}
+
+        assert configure_torch_runtime(env) is False
+        assert env["TORCH_COMPILE_DISABLE"] == configured
+
+
+def test_an_empty_value_is_treated_as_unset() -> None:
+    env = {"TORCH_COMPILE_DISABLE": "   "}
+
+    assert configure_torch_runtime(env) is True
+    assert env["TORCH_COMPILE_DISABLE"] == "1"
+
+
+def test_applied_before_torch_is_imported_by_the_cli() -> None:
+    """Ordering is the whole point: torch reads this at import time.
+
+    Importing src.main must leave the variable set, and must do so without
+    torch having been imported first — asserted by checking the flag rather
+    than trusting the import order to stay put in the file.
+    """
+    script = (
+        "import os, sys; "
+        "os.environ.pop('TORCH_COMPILE_DISABLE', None); "
+        "import src.main; "
+        "print(os.environ.get('TORCH_COMPILE_DISABLE'))"
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        cwd=REPO_CLI_ROOT,
+        capture_output=True,
+        text=True,
+        timeout=300,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr[-2000:]
+    assert result.stdout.strip().endswith("1"), result.stdout