classifyre-cli 0.4.73__tar.gz → 0.4.74__tar.gz

{classifyre_cli-0.4.73 → classifyre_cli-0.4.74}/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
 $ uv sync
-Resolved 303 packages in 168ms
+Resolved 303 packages in 170ms
 Checked 51 packages in 1ms

{classifyre_cli-0.4.73 → classifyre_cli-0.4.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classifyre-cli
-Version: 0.4.73
+Version: 0.4.74
 Summary: Classifyre CLI — scan and classify unstructured data sources
 License: MIT
 Keywords: data,ingestion,metadata,pii,secrets,unstructured
@@ -35,6 +35,35 @@ uv sync --group detectors
 # or specific groups: --group secrets --group pii --group threat ...
 ```
 
+### System dependency: LibreOffice
+
+Legacy Office formats (`.doc`, `.xls`, `.ppt`) have no usable pure-Python parser,
+so `src/utils/legacy_office.py` shells out to `soffice --headless --convert-to
+docx|xlsx|pptx` and feeds the result through the normal OOXML extractors. Without
+it those files scan as *"no content available"* — a silent coverage gap, not an
+error.
+
+- **Kubernetes**: installed in the CLI image (`libreoffice-*-nogui`), so this
+  works out of the box.
+- **Desktop and local dev**: install it yourself — `brew install --cask libreoffice`
+  (macOS), `apt install libreoffice-writer libreoffice-calc libreoffice-impress`
+  (Debian/Ubuntu), or libreoffice.org on Windows. The desktop app deliberately
+  does not bundle LibreOffice: it is ~550 MB even stripped, and slimming the
+  upstream bundle breaks its code signature, which Apple Silicon punishes by
+  killing the process on launch.
+- **Non-standard install**: set `CLASSIFYRE_SOFFICE_PATH` to the binary. The CLI
+  checks that first, then `PATH`, then the standard macOS, Windows, and
+  Linux-tarball install locations.
+
+When no binary is found the file is **not** silently reported as empty. The scan
+raises an `ENGINE_UNAVAILABLE` text-extraction coverage error that fails that
+asset's text scan, lands in `scan_stats.errors` and the run's text-coverage
+counters, and carries a platform-specific message telling the user how to install
+LibreOffice.
+
+`tests/utils/test_legacy_office.py` skips its round-trip tests when no LibreOffice
+is found, so a green local run does not by itself prove this path works.
+
 ## Command Syntax
 
 Use the thin wrapper:

{classifyre_cli-0.4.73 → classifyre_cli-0.4.74}/README.md

@@ -18,6 +18,35 @@ uv sync --group detectors
 # or specific groups: --group secrets --group pii --group threat ...
 ```
 
+### System dependency: LibreOffice
+
+Legacy Office formats (`.doc`, `.xls`, `.ppt`) have no usable pure-Python parser,
+so `src/utils/legacy_office.py` shells out to `soffice --headless --convert-to
+docx|xlsx|pptx` and feeds the result through the normal OOXML extractors. Without
+it those files scan as *"no content available"* — a silent coverage gap, not an
+error.
+
+- **Kubernetes**: installed in the CLI image (`libreoffice-*-nogui`), so this
+  works out of the box.
+- **Desktop and local dev**: install it yourself — `brew install --cask libreoffice`
+  (macOS), `apt install libreoffice-writer libreoffice-calc libreoffice-impress`
+  (Debian/Ubuntu), or libreoffice.org on Windows. The desktop app deliberately
+  does not bundle LibreOffice: it is ~550 MB even stripped, and slimming the
+  upstream bundle breaks its code signature, which Apple Silicon punishes by
+  killing the process on launch.
+- **Non-standard install**: set `CLASSIFYRE_SOFFICE_PATH` to the binary. The CLI
+  checks that first, then `PATH`, then the standard macOS, Windows, and
+  Linux-tarball install locations.
+
+When no binary is found the file is **not** silently reported as empty. The scan
+raises an `ENGINE_UNAVAILABLE` text-extraction coverage error that fails that
+asset's text scan, lands in `scan_stats.errors` and the run's text-coverage
+counters, and carries a platform-specific message telling the user how to install
+LibreOffice.
+
+`tests/utils/test_legacy_office.py` skips its round-trip tests when no LibreOffice
+is found, so a green local run does not by itself prove this path works.
+
 ## Command Syntax
 
 Use the thin wrapper:

{classifyre_cli-0.4.73 → classifyre_cli-0.4.74}/package.json

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

{classifyre_cli-0.4.73 → classifyre_cli-0.4.74}/pyproject.toml

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

{classifyre_cli-0.4.73 → classifyre_cli-0.4.74}/src/outputs/rest.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import os
 import random
 from typing import Any, Literal, cast
 from urllib.parse import urljoin
@@ -15,6 +16,18 @@ from .base import OutputRuntimeContext, OutputType
 
 logger = logging.getLogger(__name__)
 
+# Proves to the API that these write-backs come from a scan job it launched.
+# The API has no user authentication, so the ingest endpoints are restricted to
+# callers holding this shared secret; the API injects it into every CLI job's
+# environment (Kubernetes job env, or inherited from the parent process on
+# desktop). Absent locally, where the API leaves the restriction disabled.
+INTERNAL_KEY_HEADER = "X-Classifyre-Internal-Key"
+
+
+def _internal_key_headers() -> dict[str, str]:
+    key = os.environ.get("CLASSIFYRE_INTERNAL_KEY", "").strip()
+    return {INTERNAL_KEY_HEADER: key} if key else {}
+
 
 class _JitteredRetry(Retry):
     """urllib3 Retry subclass that adds ±25 % multiplicative jitter to the
@@ -164,6 +177,7 @@ class RestOutputSink:
         # a pod restart or server-side keep-alive timeout.  Each request opens
         # a fresh TCP connection, which is cheap enough for our batch cadence.
         self.session.headers.update({"Connection": "close"})
+        self.session.headers.update(_internal_key_headers())
         adapter = HTTPAdapter(max_retries=_RETRY_POLICY)
         self.session.mount("http://", adapter)
         self.session.mount("https://", adapter)

{classifyre_cli-0.4.73 → classifyre_cli-0.4.74}/src/utils/legacy_office.py

@@ -6,16 +6,25 @@ is fed back through the existing docx/xlsx/pptx extraction paths:
 
     .doc / .xls / .ppt → soffice --headless --convert-to → .docx / .xlsx / .pptx
 
-LibreOffice is an *optional system dependency*: when no ``soffice`` binary is
-found the conversion returns a structured error and callers degrade gracefully
-(the file stays a binary asset with a ``parse_error``).
+The CLI container image ships LibreOffice (the ``libreoffice-*-nogui`` Debian
+packages, which install ``/usr/bin/soffice``), so conversion works out of the box
+under Kubernetes. The desktop app deliberately does NOT bundle it — ~550 MB even
+stripped, and slimming the upstream bundle breaks its code signature — so there
+it is a system dependency the user installs.
+
+When no binary is found the file is **not** quietly reported as empty: the error
+from :func:`soffice_missing_error` propagates as an ENGINE_UNAVAILABLE text
+extraction coverage failure, which fails that asset's text scan and tells the
+user, per platform, how to install LibreOffice.
 """
 
 from __future__ import annotations
 
 import logging
+import os
 import shutil
 import subprocess
+import sys
 import tempfile
 import threading
 from functools import cache
@@ -46,13 +55,58 @@ LEGACY_OFFICE_MIME_TYPES = frozenset(_CONVERSION_TARGETS)
 
 _SOFFICE_TIMEOUT_SECONDS = 120
 
-# Non-PATH install locations checked after shutil.which().
-_SOFFICE_FALLBACK_PATHS = (
-    "/Applications/LibreOffice.app/Contents/MacOS/soffice",
-    "/usr/lib/libreoffice/program/soffice",
-    "/opt/libreoffice/program/soffice",
-    "C:\\Program Files\\LibreOffice\\program\\soffice.exe",
-)
+# How to actually get LibreOffice, per platform. The desktop app does not bundle
+# it, so this message is the entire remediation path a user gets — a generic
+# "install LibreOffice" would leave them guessing which package to install.
+_INSTALL_HINTS: dict[str, str] = {
+    "darwin": "install it with `brew install --cask libreoffice`, or from libreoffice.org",
+    "win32": "install it from https://www.libreoffice.org/download/",
+    "linux": (
+        "install it with "
+        "`apt install libreoffice-writer libreoffice-calc libreoffice-impress` "
+        "(or the equivalent for your distribution)"
+    ),
+}
+
+
+def soffice_missing_error() -> str:
+    """Actionable message for a deployment with no LibreOffice.
+
+    The word "unavailable" is load-bearing: it is what makes iter_file_pages
+    classify this as ENGINE_UNAVAILABLE rather than a per-document FAILED — the
+    difference between "this install cannot read .doc at all" and "this one file
+    is broken". test_legacy_office.py pins that mapping so the two cannot drift.
+    """
+    hint = _INSTALL_HINTS.get(sys.platform, "install LibreOffice")
+    return (
+        "LibreOffice is unavailable, so this .doc/.xls/.ppt file was NOT scanned. "
+        f"To scan legacy Office documents, {hint} — "
+        "or set CLASSIFYRE_SOFFICE_PATH to an existing soffice binary."
+    )
+
+
+# Explicit override, checked before anything else. The desktop app rebuilds a
+# minimal PATH for the processes it spawns, so an installation it discovered
+# itself is handed down through this variable rather than through PATH.
+SOFFICE_PATH_ENV = "CLASSIFYRE_SOFFICE_PATH"
+
+# Install locations to check when PATH comes up empty, keyed by sys.platform.
+# macOS and Windows always need these: their installers drop the binary inside an
+# app bundle / Program Files without touching PATH, and the packaged desktop app
+# rebuilds a minimal PATH that cannot see either. Linux only needs them for an
+# upstream tarball install — the distro packages (including the
+# libreoffice-*-nogui ones in the CLI image) all land on /usr/bin/soffice.
+_SOFFICE_FALLBACK_PATHS: dict[str, tuple[str, ...]] = {
+    "darwin": ("/Applications/LibreOffice.app/Contents/MacOS/soffice",),
+    "linux": (
+        "/opt/libreoffice/program/soffice",
+        "/usr/lib/libreoffice/program/soffice",
+    ),
+    "win32": (
+        "C:\\Program Files\\LibreOffice\\program\\soffice.exe",
+        "C:\\Program Files (x86)\\LibreOffice\\program\\soffice.exe",
+    ),
+}
 
 # One conversion at a time: each soffice launch is a full process spinning up
 # ~200 MB; serializing keeps peak memory bounded alongside detector workloads.
@@ -61,14 +115,36 @@ _conversion_lock = threading.Lock()
 
 @cache
 def find_soffice() -> str | None:
-    """Locate the LibreOffice binary, or None when it is not installed."""
+    """Locate the LibreOffice binary, or None when it is not installed.
+
+    Resolution order, most explicit first:
+
+    1. ``CLASSIFYRE_SOFFICE_PATH`` — an operator/desktop-supplied absolute path.
+    2. ``PATH`` — the CLI container, Linux hosts, and dev shells.
+    3. Platform install locations — macOS/Windows only (see the table above).
+
+    Cached: the answer cannot change within a process. Tests that manipulate the
+    environment must call ``find_soffice.cache_clear()``.
+    """
+    override = os.environ.get(SOFFICE_PATH_ENV, "").strip()
+    if override:
+        if Path(override).is_file():
+            return override
+        logger.warning(
+            "%s=%s does not point at an existing file; falling back to PATH lookup",
+            SOFFICE_PATH_ENV,
+            override,
+        )
+
     for name in ("soffice", "libreoffice"):
         path = shutil.which(name)
         if path:
             return path
-    for candidate in _SOFFICE_FALLBACK_PATHS:
-        if Path(candidate).exists():
+
+    for candidate in _SOFFICE_FALLBACK_PATHS.get(sys.platform, ()):
+        if Path(candidate).is_file():
             return candidate
+
     return None
 
 
@@ -90,12 +166,7 @@ def convert_legacy_office(
 
     soffice = find_soffice()
     if soffice is None:
-        return (
-            None,
-            target_mime,
-            "LibreOffice (soffice) not found; install LibreOffice to enable "
-            ".doc/.xls/.ppt extraction",
-        )
+        return None, target_mime, soffice_missing_error()
 
     try:
         with tempfile.TemporaryDirectory(prefix="classifyre-soffice-") as temp_dir:

classifyre_cli-0.4.74/tests/utils/test_legacy_office.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from src.utils import legacy_office
+from src.utils.legacy_office import SOFFICE_PATH_ENV, convert_legacy_office, find_soffice
+
+_DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+_XLSX_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+_PPTX_MIME = "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+
+
+@pytest.fixture(autouse=True)
+def _clear_soffice_cache() -> object:
+    """find_soffice() is @cache'd, so every environment tweak needs a reset."""
+    find_soffice.cache_clear()
+    yield
+    find_soffice.cache_clear()
+
+
+class TestFindSoffice:
+    """The resolution contract each deployment relies on.
+
+    Kubernetes finds /usr/bin/soffice on PATH (the libreoffice-*-nogui packages
+    baked into the CLI image); the packaged desktop app rebuilds a minimal PATH
+    that excludes /Applications, so macOS and Windows depend on the platform
+    fallback table; operators and the desktop override both with an env var.
+    """
+
+    def test_env_override_wins_over_path(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        override = tmp_path / "custom-soffice"
+        override.write_text("#!/bin/sh\n")
+        monkeypatch.setattr(legacy_office.shutil, "which", lambda _name: "/usr/bin/soffice")
+        monkeypatch.setenv(SOFFICE_PATH_ENV, str(override))
+
+        assert find_soffice() == str(override)
+
+    def test_env_override_pointing_nowhere_falls_back_to_path(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        monkeypatch.setattr(
+            legacy_office.shutil,
+            "which",
+            lambda name: "/usr/bin/soffice" if name == "soffice" else None,
+        )
+        monkeypatch.setenv(SOFFICE_PATH_ENV, str(tmp_path / "does-not-exist"))
+
+        assert find_soffice() == "/usr/bin/soffice"
+
+    def test_path_lookup_finds_container_install(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """The CLI image installs /usr/bin/soffice; no fallback should be needed."""
+        monkeypatch.delenv(SOFFICE_PATH_ENV, raising=False)
+        monkeypatch.setattr(
+            legacy_office.shutil,
+            "which",
+            lambda name: "/usr/bin/soffice" if name == "soffice" else None,
+        )
+        monkeypatch.setattr(legacy_office.sys, "platform", "linux")
+
+        assert find_soffice() == "/usr/bin/soffice"
+
+    @pytest.mark.parametrize("platform", ["darwin", "win32", "linux"])
+    def test_platform_fallback_used_when_path_is_scrubbed(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path, platform: str
+    ) -> None:
+        """Reproduces packaged-desktop mode: PATH holds no LibreOffice at all.
+
+        macOS/Windows installers never touch PATH, and the packaged app rebuilds
+        a minimal one; on Linux this covers an upstream tarball install in /opt.
+        """
+        installed = tmp_path / "soffice"
+        installed.write_text("#!/bin/sh\n")
+        monkeypatch.delenv(SOFFICE_PATH_ENV, raising=False)
+        monkeypatch.setattr(legacy_office.shutil, "which", lambda _name: None)
+        monkeypatch.setattr(legacy_office.sys, "platform", platform)
+        monkeypatch.setitem(legacy_office._SOFFICE_FALLBACK_PATHS, platform, (str(installed),))
+
+        assert find_soffice() == str(installed)
+
+    @pytest.mark.parametrize("platform", ["darwin", "win32", "linux"])
+    def test_every_supported_platform_has_fallback_paths(self, platform: str) -> None:
+        """A platform missing from the table silently loses discovery on hosts
+        whose installer does not touch PATH."""
+        assert legacy_office._SOFFICE_FALLBACK_PATHS.get(platform)
+
+    def test_fallback_paths_are_absolute(self) -> None:
+        for platform, candidates in legacy_office._SOFFICE_FALLBACK_PATHS.items():
+            for candidate in candidates:
+                assert candidate.startswith(("/", "C:\\")), f"{platform}: {candidate}"
+
+    def test_missing_everywhere_returns_none(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv(SOFFICE_PATH_ENV, raising=False)
+        monkeypatch.setattr(legacy_office.shutil, "which", lambda _name: None)
+        monkeypatch.setattr(legacy_office.sys, "platform", "darwin")
+        monkeypatch.setitem(legacy_office._SOFFICE_FALLBACK_PATHS, "darwin", ())
+
+        assert find_soffice() is None
+
+
+class TestConvertLegacyOffice:
+    def test_unsupported_mime_returns_error(self) -> None:
+        converted, target_mime, error = convert_legacy_office(b"data", "application/pdf")
+        assert converted is None
+        assert target_mime == ""
+        assert error is not None and "Unsupported" in error
+
+    def test_missing_soffice_returns_structured_error(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setattr(legacy_office, "find_soffice", lambda: None)
+        converted, target_mime, error = convert_legacy_office(b"data", "application/msword")
+        assert converted is None
+        assert target_mime == _DOCX_MIME
+        assert error is not None and "LibreOffice" in error
+
+    def test_missing_soffice_is_reported_as_engine_unavailable(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """A missing binary is a broken deployment, not a broken document.
+
+        iter_file_pages must raise — a silent empty result would let the asset be
+        recorded as scanned-and-empty, which is indistinguishable from a genuinely
+        empty file. The ENGINE_UNAVAILABLE code is what separates "this install
+        cannot read .doc at all" from "this one file failed".
+        """
+        from src.utils.file_parser import (
+            TextExtractionCoverageCode,
+            TextExtractionCoverageError,
+            iter_file_pages,
+        )
+
+        monkeypatch.setattr(legacy_office, "find_soffice", lambda: None)
+
+        with pytest.raises(TextExtractionCoverageError) as excinfo:
+            list(iter_file_pages(b"\xd0\xcf\x11\xe0", "application/msword", file_name="x.doc"))
+
+        assert excinfo.value.code is TextExtractionCoverageCode.ENGINE_UNAVAILABLE
+        # The operator has to be able to act on it without reading our source.
+        assert "CLASSIFYRE_SOFFICE_PATH" in str(excinfo.value)
+
+    @pytest.mark.parametrize(
+        ("platform", "expected_hint"),
+        [
+            ("darwin", "brew install --cask libreoffice"),
+            ("win32", "libreoffice.org/download"),
+            ("linux", "apt install libreoffice-writer"),
+        ],
+    )
+    def test_install_hint_matches_the_platform(
+        self, monkeypatch: pytest.MonkeyPatch, platform: str, expected_hint: str
+    ) -> None:
+        """The desktop app ships no LibreOffice, so this message is the user's
+        whole remediation path — a macOS user must not be told to run apt."""
+        monkeypatch.setattr(legacy_office.sys, "platform", platform)
+
+        message = legacy_office.soffice_missing_error()
+
+        assert expected_hint in message
+        # Keeps the ENGINE_UNAVAILABLE classification working (see iter_file_pages).
+        assert "unavailable" in message.casefold()
+
+    def test_install_hint_falls_back_on_unknown_platform(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setattr(legacy_office.sys, "platform", "freebsd14")
+
+        message = legacy_office.soffice_missing_error()
+
+        assert "install LibreOffice" in message
+        assert "unavailable" in message.casefold()
+
+
+# Fixture bodies chosen so LibreOffice can genuinely *import* them: Writer reads
+# plain text, Calc reads CSV, Impress reads flat ODF. (Feeding .txt to Calc or
+# Impress fails with "no export filter" and silently produces nothing.)
+_SAMPLE_TEXT = "Legacy document body text."
+_SAMPLE_CSV = "name,ssn\nAlice,123-45-6789\n"
+_SAMPLE_FODP = """<?xml version="1.0" encoding="UTF-8"?>
+<office:document xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"
+ xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0"
+ xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0"
+ xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0"
+ office:version="1.2"
+ office:mimetype="application/vnd.oasis.opendocument.presentation">
+ <office:body><office:presentation>
+  <draw:page draw:name="page1">
+   <draw:frame svg:width="10cm" svg:height="2cm" svg:x="1cm" svg:y="1cm">
+    <draw:text-box><text:p>Legacy slide body text.</text:p></draw:text-box>
+   </draw:frame>
+  </draw:page>
+ </office:presentation></office:body>
+</office:document>
+"""
+
+
+def _build_legacy_fixture(tmp_path: Path, file_name: str, body: str, legacy_ext: str) -> bytes:
+    """Produce a genuine legacy binary (.doc/.xls/.ppt) with the same soffice."""
+    import subprocess
+
+    soffice = find_soffice()
+    assert soffice is not None
+    source = tmp_path / file_name
+    source.write_text(body)
+    subprocess.run(
+        [
+            soffice,
+            "--headless",
+            "--norestore",
+            f"-env:UserInstallation={(tmp_path / 'fixture-profile').as_uri()}",
+            "--convert-to",
+            legacy_ext,
+            "--outdir",
+            str(tmp_path),
+            str(source),
+        ],
+        capture_output=True,
+        timeout=120,
+        check=True,
+    )
+    produced = tmp_path / f"{source.stem}.{legacy_ext}"
+    assert produced.is_file(), f"LibreOffice did not produce {produced.name}"
+    return produced.read_bytes()
+
+
+@pytest.mark.skipif(find_soffice() is None, reason="LibreOffice not installed")
+class TestLegacyOfficeRoundTrip:
+    """Covers all three formats the CLI image installs an import filter for.
+
+    Each one needs its own libreoffice-*-nogui package, so a per-format test is
+    what catches a Dockerfile that dropped calc or impress.
+    """
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            ("sample.txt", _SAMPLE_TEXT, "doc", "application/msword", _DOCX_MIME),
+            ("sample.csv", _SAMPLE_CSV, "xls", "application/vnd.ms-excel", _XLSX_MIME),
+            ("sample.fodp", _SAMPLE_FODP, "ppt", "application/vnd.ms-powerpoint", _PPTX_MIME),
+        ],
+        ids=["doc", "xls", "ppt"],
+    )
+    def test_legacy_binary_converts_to_ooxml(
+        self,
+        tmp_path: Path,
+        case: tuple[str, str, str, str, str],
+    ) -> None:
+        file_name, body, legacy_ext, legacy_mime, target_mime = case
+        legacy_bytes = _build_legacy_fixture(tmp_path, file_name, body, legacy_ext)
+
+        converted, resolved_mime, error = convert_legacy_office(legacy_bytes, legacy_mime)
+
+        assert error is None
+        assert resolved_mime == target_mime
+        assert converted is not None and converted.startswith(b"PK\x03\x04")
+
+    def test_doc_text_reaches_detectors(self, tmp_path: Path) -> None:
+        from src.utils.file_parser import extract_text
+
+        doc_bytes = _build_legacy_fixture(tmp_path, "sample.txt", _SAMPLE_TEXT, "doc")
+
+        text, extract_error = extract_text(doc_bytes, "application/msword", file_name="sample.doc")
+
+        assert extract_error is None
+        assert _SAMPLE_TEXT in text
+
+    def test_xls_cell_values_reach_detectors(self, tmp_path: Path) -> None:
+        """The Enron corpus failure case: a .xls scanned as "no content"."""
+        from src.utils.file_parser import extract_text
+
+        xls_bytes = _build_legacy_fixture(tmp_path, "sample.csv", _SAMPLE_CSV, "xls")
+
+        text, extract_error = extract_text(
+            xls_bytes, "application/vnd.ms-excel", file_name="sample.xls"
+        )
+
+        assert extract_error is None
+        assert "123-45-6789" in text

{classifyre_cli-0.4.73 → classifyre_cli-0.4.74}/uv.lock

@@ -176,11 +176,11 @@ wheels = [
 
 [[package]]
 name = "annotated-doc"
-version = "0.0.4"
+version = "0.0.5"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" },
 ]
 
 [[package]]
@@ -830,7 +830,7 @@ wheels = [
 
 [[package]]
 name = "classifyre-cli"
-version = "0.4.73"
+version = "0.4.74"
 source = { editable = "." }
 dependencies = [
     { name = "beautifulsoup4" },
@@ -1355,7 +1355,7 @@ youtube = [
 
 [[package]]
 name = "classifyre-schemas"
-version = "0.4.73"
+version = "0.4.74"
 source = { editable = "../../packages/schemas" }
 dependencies = [
     { name = "fastjsonschema" },
@@ -4040,7 +4040,7 @@ wheels = [
 
 [[package]]
 name = "peft"
-version = "0.19.1"
+version = "0.20.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "accelerate" },
@@ -4056,9 +4056,9 @@ dependencies = [
     { name = "transformers", version = "5.8.1", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin'" },
     { name = "transformers", version = "5.14.1", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'darwin'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/86/cf/037f1e3d5186496c05513a6754639e2dab3038a05f384284d49a9bd06a2d/peft-0.19.1.tar.gz", hash = "sha256:0d97542fe96dcdaa20d3b81c06f26f988618f416a73544ab23c3618ccb674a40", size = 763738, upload-time = "2026-04-16T15:46:45.105Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b4/08/02541a2c29be7c78698f73d438bc0e733b214f3f35ec5db79fca8da8fc61/peft-0.20.0.tar.gz", hash = "sha256:4769c8093a4ca145fd6fb3fd4dd50449675f5fe46434ad1e98b285a132d4b1d0", size = 880503, upload-time = "2026-07-28T13:46:01.85Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e8/b6/f54d676ed93cc2dd2234c3b172ea9c8c3d7d29361e66b1b23dec57a67465/peft-0.19.1-py3-none-any.whl", hash = "sha256:2113f72a81621b5913ef28f9022204c742df111890c5f49d812716a4a301e356", size = 680692, upload-time = "2026-04-16T15:46:42.886Z" },
+    { url = "https://files.pythonhosted.org/packages/28/79/13bcabb8048126422d5c4b880575d40886c726f354db88cfeed4325525bb/peft-0.20.0-py3-none-any.whl", hash = "sha256:0fbba16ffebfad3de96e06f2da6860fd860292324b85b6141909fa1e26ea9233", size = 775777, upload-time = "2026-07-28T13:45:59.809Z" },
 ]
 
 [[package]]