classifyre-cli 0.4.56__tar.gz → 0.4.57__tar.gz

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
 $ uv sync
-Resolved 292 packages in 322ms
+Resolved 292 packages in 247ms
 Checked 51 packages in 1ms

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classifyre-cli
-Version: 0.4.56
+Version: 0.4.57
 Summary: Classifyre CLI — scan and classify unstructured data sources
 License: MIT
 Keywords: data,ingestion,metadata,pii,secrets,unstructured
@@ -54,7 +54,7 @@ Commands:
 - `test` - test source connection.
 - `discover` - discover source resources.
 - `extract` - run extraction and emit batched output.
-- `sandbox` - run sandbox parsing/detectors for a local file.
+- `evaluate-file` - internally evaluate detectors against one local file.
 
 ## Extract Output Model
 
@@ -78,7 +78,7 @@ Default behavior:
 Global/common:
 
 - `--debug` - enable debug logging.
-- `--detectors-file <path>` - sandbox only.
+- `--detectors-file <path>` - file evaluation only.
 
 Extract output options:
 

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/README.md

@@ -37,7 +37,7 @@ Commands:
 - `test` - test source connection.
 - `discover` - discover source resources.
 - `extract` - run extraction and emit batched output.
-- `sandbox` - run sandbox parsing/detectors for a local file.
+- `evaluate-file` - internally evaluate detectors against one local file.
 
 ## Extract Output Model
 
@@ -61,7 +61,7 @@ Default behavior:
 Global/common:
 
 - `--debug` - enable debug logging.
-- `--detectors-file <path>` - sandbox only.
+- `--detectors-file <path>` - file evaluation only.
 
 Extract output options:
 

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/package.json

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

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/pyproject.toml

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

classifyre_cli-0.4.57/src/file_evaluation/__init__.py

@@ -0,0 +1,5 @@
+"""Internal runner for evaluating detectors on local files."""
+
+from .runner import FileEvaluationRunner
+
+__all__ = ["FileEvaluationRunner"]

{classifyre_cli-0.4.56/src/sandbox → classifyre_cli-0.4.57/src/file_evaluation}/runner.py

@@ -1,4 +1,4 @@
-"""SandboxRunner: run detectors on a local file."""
+"""FileEvaluationRunner: run detectors on an ephemeral local file."""
 
 from __future__ import annotations
 
@@ -15,7 +15,7 @@ from ..utils.file_parser import ParsedFile, parse_file
 logger = logging.getLogger(__name__)
 
 
-class SandboxRunner:
+class FileEvaluationRunner:
     """Run a set of detectors against a single local file."""
 
     def __init__(self, detectors_config: list[dict[str, Any]]) -> None:
@@ -41,7 +41,7 @@ class SandboxRunner:
 
                 detector = get_detector(detector_name, typed_config)
                 detectors.append(detector)
-                logger.info(f"Initialized sandbox detector: {detector_name}")
+                logger.info(f"Initialized file-evaluation detector: {detector_name}")
             except Exception as e:
                 logger.error(f"Failed to initialize detector {detector_type}: {e}")
 
@@ -121,19 +121,23 @@ class SandboxRunner:
                 and self._is_binary_detector(detector)
                 and self._supports_mime(supported, mime_type)
             ):
-                logger.info("Sandbox: dispatching '%s' on file bytes (%s)", label, mime_type)
+                logger.info(
+                    "File evaluation: dispatching '%s' on file bytes (%s)", label, mime_type
+                )
                 tasks.append(detector.detect(_get_raw_bytes(), mime_type))
                 active_detectors.append(detector)
             # Text delivery: text detectors get the extracted text layer.
             elif "text/plain" in supported and text.strip():
                 logger.info(
-                    "Sandbox: dispatching '%s' on extracted text (%d chars)", label, len(text)
+                    "File evaluation: dispatching '%s' on extracted text (%d chars)",
+                    label,
+                    len(text),
                 )
                 tasks.append(detector.detect(text, "text/plain"))
                 active_detectors.append(detector)
             else:
                 logger.info(
-                    "Sandbox: '%s' not dispatched on whole file (supports=%s, file_mime=%s)",
+                    "File evaluation: '%s' not dispatched on whole file (supports=%s, file_mime=%s)",
                     label,
                     supported,
                     file_mime,
@@ -158,18 +162,20 @@ class SandboxRunner:
         for detector, result in zip(active_detectors, results, strict=False):
             label = self._detector_label(detector)
             if isinstance(result, Exception):
-                logger.error("Sandbox: '%s' failed on whole file: %s", label, result)
+                logger.error("File evaluation: '%s' failed on whole file: %s", label, result)
                 continue
             if isinstance(result, list):
                 detector_findings = [f for f in result if isinstance(f, DetectionResult)]
                 logger.info(
-                    "Sandbox: '%s' on whole file → %d finding(s)", label, len(detector_findings)
+                    "File evaluation: '%s' on whole file → %d finding(s)",
+                    label,
+                    len(detector_findings),
                 )
                 for finding in detector_findings:
                     all_findings.append(
                         finding.model_copy(
                             update={
-                                "runner_id": "sandbox",
+                                "runner_id": "file-evaluation",
                                 "detected_at": detected_at,
                             }
                         )
@@ -203,14 +209,14 @@ class SandboxRunner:
         binary_detectors = [d for d in detectors if self._is_binary_detector(d)]
         if not binary_detectors:
             logger.info(
-                "Sandbox: %s embeds images but no image-capable detectors are configured; "
+                "File evaluation: %s embeds images but no image-capable detectors are configured; "
                 "skipping embedded-image scan",
                 mime_type,
             )
             return []
 
         logger.info(
-            "Sandbox: scanning images embedded in %s with image detectors: [%s]",
+            "File evaluation: scanning images embedded in %s with image detectors: [%s]",
             mime_type,
             ", ".join(self._detector_label(d) for d in binary_detectors),
         )
@@ -227,14 +233,14 @@ class SandboxRunner:
             ]
             if not compatible:
                 logger.info(
-                    "Sandbox: embedded image %s (%s, %.0f KB) — no compatible detector",
+                    "File evaluation: embedded image %s (%s, %.0f KB) — no compatible detector",
                     image.location,
                     image.mime_type,
                     size_kb,
                 )
                 continue
             logger.info(
-                "Sandbox: embedded image %s (%s, %.0f KB) → dispatching [%s]",
+                "File evaluation: embedded image %s (%s, %.0f KB) → dispatching [%s]",
                 image.location,
                 image.mime_type,
                 size_kb,
@@ -246,7 +252,7 @@ class SandboxRunner:
                     result = await detector.detect(image.image_bytes, image.mime_type)
                 except Exception as exc:
                     logger.error(
-                        "Sandbox: '%s' failed on embedded image %s: %s",
+                        "File evaluation: '%s' failed on embedded image %s: %s",
                         label,
                         image.location,
                         exc,
@@ -258,7 +264,7 @@ class SandboxRunner:
                     else []
                 )
                 logger.info(
-                    "Sandbox: '%s' on embedded image %s → %d finding(s)",
+                    "File evaluation: '%s' on embedded image %s → %d finding(s)",
                     label,
                     image.location,
                     len(detector_findings),
@@ -267,7 +273,7 @@ class SandboxRunner:
                     findings.append(self._tag_embedded(finding, image.location, detected_at))
 
         logger.info(
-            "Sandbox: embedded-image scan complete — %d image(s) scanned, %d finding(s)",
+            "File evaluation: embedded-image scan complete — %d image(s) scanned, %d finding(s)",
             image_count,
             len(findings),
         )
@@ -296,7 +302,7 @@ class SandboxRunner:
             location = location.model_copy(update={"path": location_label})
         return finding.model_copy(
             update={
-                "runner_id": "sandbox",
+                "runner_id": "file-evaluation",
                 "detected_at": detected_at,
                 "metadata": metadata,
                 "location": location,

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/src/main.py

@@ -131,6 +131,10 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
     source_id = args.source_id or os.environ.get("SOURCE_ID")
     if source_id:
         os.environ["SOURCE_ID"] = source_id
+    if getattr(args, "output_rest_url", None):
+        # Sources such as SANDBOX use the same managed-job API base URL as the
+        # REST output sink to list and stream their input content.
+        os.environ["CLASSIFYRE_OUTPUT_REST_URL"] = args.output_rest_url
 
     try:
         try:
@@ -461,13 +465,13 @@ def run_train_command(args: argparse.Namespace) -> None:
     print(json.dumps(result.to_dict()))
 
 
-def run_sandbox_command(args: argparse.Namespace) -> None:
-    """Execute the sandbox command: parse file + run detectors."""
-    from .sandbox import SandboxRunner
+def run_evaluate_file_command(args: argparse.Namespace) -> None:
+    """Evaluate detector configs against one ephemeral local file."""
+    from .file_evaluation import FileEvaluationRunner
 
     file_path_str: str | None = args.recipe
     if not file_path_str:
-        logger.error("sandbox command requires a file path as the first argument")
+        logger.error("evaluate-file requires a file path as the first argument")
         sys.exit(1)
 
     file_path = Path(file_path_str)
@@ -492,7 +496,7 @@ def run_sandbox_command(args: argparse.Namespace) -> None:
             sys.exit(1)
 
     try:
-        runner = SandboxRunner(detectors)
+        runner = FileEvaluationRunner(detectors)
         parsed, findings = runner.run(file_path)
         if parsed.parse_error:
             logger.warning("File parse warning: %s", parsed.parse_error)
@@ -504,7 +508,7 @@ def run_sandbox_command(args: argparse.Namespace) -> None:
             output["parse_error"] = parsed.parse_error
         print(json.dumps(_sanitize_for_json(output), ensure_ascii=False))
     except Exception as e:
-        logger.error("Sandbox run failed: %s", e, exc_info=True)
+        logger.error("File evaluation failed: %s", e, exc_info=True)
         sys.exit(1)
 
 
@@ -520,14 +524,14 @@ def main() -> None:
     parser = argparse.ArgumentParser(description="Classifyre Metadata Extraction CLI")
     parser.add_argument(
         "command",
-        choices=["test", "extract", "discover", "sandbox", "train"],
+        choices=["test", "extract", "discover", "evaluate-file", "train"],
         help="Command to run",
     )
     parser.add_argument(
         "recipe",
         nargs="?",
         default=None,
-        help="Path to recipe JSON (or file path for sandbox command)",
+        help="Path to recipe JSON (or file path for evaluate-file)",
     )
     parser.add_argument("--debug", action="store_true", help="Enable debug logging")
     parser.add_argument(
@@ -565,7 +569,7 @@ def main() -> None:
     parser.add_argument(
         "--detectors-file",
         default=None,
-        help="Path to JSON file with detector configs (sandbox command only)",
+        help="Path to JSON file with detector configs (evaluate-file only)",
     )
     # train-command arguments
     parser.add_argument(
@@ -629,8 +633,8 @@ def main() -> None:
     if args.debug:
         logging.getLogger().setLevel(logging.DEBUG)
 
-    if args.command == "sandbox":
-        run_sandbox_command(args)
+    if args.command == "evaluate-file":
+        run_evaluate_file_command(args)
         return
 
     if args.command == "train":

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/src/models/generated_detectors.py

@@ -75,6 +75,7 @@ class SourceAssetType(StrEnum):
     ORACLE = 'ORACLE'
     HIVE = 'HIVE'
     POWERBI = 'POWERBI'
+    SANDBOX = 'SANDBOX'
 
 
 class DetectorLifecycleStatus(StrEnum):

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/src/models/generated_input.py

@@ -54,6 +54,7 @@ class AssetType(StrEnum):
     LOCAL_FOLDER = 'LOCAL_FOLDER'
     MICROSOFT_365 = 'MICROSOFT_365'
     GOOGLE_WORKSPACE = 'GOOGLE_WORKSPACE'
+    SANDBOX = 'SANDBOX'
 
 
 class DetectorType(StrEnum):
@@ -353,6 +354,7 @@ class Type(StrEnum):
     LOCAL_FOLDER = 'LOCAL_FOLDER'
     MICROSOFT_365 = 'MICROSOFT_365'
     GOOGLE_WORKSPACE = 'GOOGLE_WORKSPACE'
+    SANDBOX = 'SANDBOX'
 
 
 class YouTubeRequired(BaseModel):
@@ -648,6 +650,32 @@ class LocalFolderRequired(BaseModel):
     )
 
 
+class SandboxRequired(BaseModel):
+    """
+    Sandbox files are uploaded separately through the source files API.
+    """
+
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+
+
+class SandboxMasked(BaseModel):
+    """
+    Sandbox sources do not require credentials.
+    """
+
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+
+
+class SandboxOptional(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+
+
 class LocalFolderMasked(BaseModel):
     """
     Local folder scans run with the desktop application's filesystem permissions; no credentials are required.
@@ -2170,6 +2198,24 @@ class LocalFolderInput(CoreInput):
     resources: ResourceOverrides | None = None
 
 
+class SandboxInput(CoreInput):
+    type: Literal['SANDBOX'] | None = Field(
+        None, description='Type of the asset or source'
+    )
+    required: SandboxRequired
+    masked: SandboxMasked | None = None
+    optional: SandboxOptional | None = None
+    detectors: list[Detector] | None = Field(
+        None, description='Detectors to run on ingested content'
+    )
+    custom_detectors: list[CustomDetectorSelection] | None = Field(
+        None,
+        description='Reusable custom detector IDs selected from the custom detector catalog.',
+    )
+    sampling: SamplingConfig
+    resources: ResourceOverrides | None = None
+
+
 class AzureBlobStorageInput(CoreInput):
     type: Literal['AZURE_BLOB_STORAGE'] | None = Field(
         None, description='Type of the asset or source'
@@ -2601,7 +2647,7 @@ class ConfluenceOptionalConnection(BaseModel):
     )
 
 
-class Type19(StrEnum):
+class Type20(StrEnum):
     """
     Filter spaces by space type
     """
@@ -2638,7 +2684,7 @@ class ConfluenceOptionalScopeSpaces(BaseModel):
     keys: list[str] | None = Field(
         None, description='Filter spaces by keys (up to 250)', max_length=250
     )
-    type: Type19 | None = Field(None, description='Filter spaces by space type')
+    type: Type20 | None = Field(None, description='Filter spaces by space type')
     status: Status | None = Field(None, description='Filter spaces by status')
     labels: list[str] | None = Field(
         None,
@@ -2904,7 +2950,7 @@ class ServiceDeskOptional(BaseModel):
     content: ServiceDeskOptionalContent | None = None
 
 
-class Type20(StrEnum):
+class Type21(StrEnum):
     """
     Type of the asset or source
     """
@@ -2941,6 +2987,7 @@ class Type20(StrEnum):
     LOCAL_FOLDER = 'LOCAL_FOLDER'
     MICROSOFT_365 = 'MICROSOFT_365'
     GOOGLE_WORKSPACE = 'GOOGLE_WORKSPACE'
+    SANDBOX = 'SANDBOX'
 
 
 class ConfluenceInput(CoreInput):
@@ -4075,7 +4122,8 @@ class IcebergInput(CoreInput):
 
 class SourceInput(
     RootModel[
-        SlackInput
+        SandboxInput
+        | SlackInput
         | S3CompatibleStorageInput
         | LocalFolderInput
         | AzureBlobStorageInput
@@ -4110,7 +4158,8 @@ class SourceInput(
     ]
 ):
     root: (
-        SlackInput
+        SandboxInput
+        | SlackInput
         | S3CompatibleStorageInput
         | LocalFolderInput
         | AzureBlobStorageInput

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/src/sources/object_storage/base.py

@@ -303,6 +303,10 @@ class ObjectStorageSourceBase(BaseSource, ABC):
     def _file_extension(self, key: str) -> str:
         return PurePosixPath(key).suffix.lower()
 
+    def _object_file_name(self, ref: ObjectRef) -> str:
+        """File name used for MIME inference and normalized metadata."""
+        return ref.key
+
     def _asset_type_from_mime_or_key(self, mime_type: str | None, key: str) -> OutputAssetType:
         normalized_mime = (mime_type or "").split(";", maxsplit=1)[0].strip().lower()
         extension = self._file_extension(key)
@@ -364,7 +368,7 @@ class ObjectStorageSourceBase(BaseSource, ABC):
         if self._discovery_only or not self._include_content_preview():
             mime = (ref.content_type_hint or "").split(";", maxsplit=1)[0].strip().lower()
             if not mime:
-                mime = infer_mime_type_from_file_name(ref.key)
+                mime = infer_mime_type_from_file_name(self._object_file_name(ref))
             return ContentSnapshot(
                 mime_type=mime or "application/octet-stream",
                 raw_content="",
@@ -389,7 +393,7 @@ class ObjectStorageSourceBase(BaseSource, ABC):
         mime_type = resolve_mime_type(
             file_bytes,
             declared_mime_type=content_type_hint or ref.content_type_hint or "",
-            file_name=ref.key,
+            file_name=self._object_file_name(ref),
         )
         normalized_mime = mime_type.split(";", 1)[0].strip().lower()
 
@@ -414,7 +418,8 @@ class ObjectStorageSourceBase(BaseSource, ABC):
         asset_hash = self.generate_hash_id(external_url)
 
         snapshot = self._build_snapshot(ref)
-        asset_type = self._asset_type_from_mime_or_key(snapshot.mime_type, ref.key)
+        file_name = self._object_file_name(ref)
+        asset_type = self._asset_type_from_mime_or_key(snapshot.mime_type, file_name)
 
         if snapshot.text_content:
             self._content_cache[asset_hash] = (snapshot.raw_content, snapshot.text_content)
@@ -459,14 +464,14 @@ class ObjectStorageSourceBase(BaseSource, ABC):
             file_meta = extract_file_metadata(
                 snapshot.raw_bytes,
                 snapshot.mime_type,
-                file_name=ref.key,
+                file_name=file_name,
             )
             asset_metadata.update({k: v for k, v in file_meta.items() if v is not None})
 
         asset = SingleAssetScanResults(
             hash=asset_hash,
             checksum=self.calculate_checksum(metadata),
-            name=ref.key.split("/")[-1] or ref.key,
+            name=file_name.split("/")[-1] or file_name,
             external_url=external_url,
             links=[],
             asset_type=asset_type,

classifyre_cli-0.4.57/src/sources/sandbox/__init__.py

@@ -0,0 +1,3 @@
+from .source import SandboxSource
+
+__all__ = ["SandboxSource"]

classifyre_cli-0.4.57/src/sources/sandbox/source.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Iterator
+from datetime import UTC, datetime
+from typing import Any
+from urllib.parse import quote
+
+import requests
+
+from ...models.generated_input import SandboxInput
+from ..object_storage.base import ObjectRef, ObjectStorageSourceBase
+
+logger = logging.getLogger(__name__)
+
+
+class SandboxSource(ObjectStorageSourceBase):
+    """Uploaded files exposed by the API as a normal ingestion source."""
+
+    source_type = "sandbox"
+    provider_label = "SANDBOX"
+    input_model = SandboxInput
+
+    def __init__(
+        self,
+        recipe: dict[str, Any],
+        source_id: str | None = None,
+        runner_id: str | None = None,
+    ) -> None:
+        if not source_id:
+            raise ValueError("SANDBOX requires a source ID")
+        super().__init__(recipe, source_id=source_id, runner_id=runner_id)
+        self._api_url = (
+            os.environ.get("CLASSIFYRE_OUTPUT_REST_URL")
+            or os.environ.get("API_URL")
+            or "http://localhost:8000"
+        ).rstrip("/")
+        self._session = requests.Session()
+        self._file_by_id: dict[str, dict[str, Any]] = {}
+
+    def _scope_option(self, key: str, default: Any = None) -> Any:
+        # SANDBOX intentionally has an empty optional config section; uploaded
+        # files are always in scope and always include their content.
+        return default
+
+    def _connection_option(self, key: str, default: Any = None) -> Any:
+        return default
+
+    def _max_object_bytes(self) -> int:
+        # Keep the extractor aligned with the API's per-upload limit instead
+        # of the object-storage connector family's conservative 5 MiB default.
+        return 50 * 1024 * 1024
+
+    def _request(self, method: str, path: str, *, stream: bool = False) -> requests.Response:
+        response = self._session.request(
+            method,
+            f"{self._api_url}{path}",
+            timeout=120,
+            stream=stream,
+            headers={"Connection": "close"},
+        )
+        response.raise_for_status()
+        return response
+
+    def _list_objects(self) -> Iterator[ObjectRef]:
+        response = self._request("GET", f"/sources/{self.source_id}/files")
+        payload = response.json()
+        if not isinstance(payload, list):
+            raise ValueError("Source files API returned a non-array response")
+
+        self._file_by_id = {}
+        for item in payload:
+            if not isinstance(item, dict) or not item.get("id"):
+                continue
+            file_id = str(item["id"])
+            self._file_by_id[file_id] = item
+            created_at = str(item.get("createdAt") or "").replace("Z", "+00:00")
+            try:
+                modified = datetime.fromisoformat(created_at)
+                if modified.tzinfo is None:
+                    modified = modified.replace(tzinfo=UTC)
+            except ValueError:
+                modified = datetime.now(UTC)
+            yield ObjectRef(
+                key=file_id,
+                size=int(item.get("fileSizeBytes") or 0),
+                last_modified=modified,
+                etag=str(item.get("contentHash") or "") or None,
+                content_type_hint=str(item.get("declaredMimeType") or "application/octet-stream"),
+            )
+
+    def _download_object(self, ref: ObjectRef) -> tuple[bytes, str | None]:
+        response = self._request(
+            "GET",
+            f"/sources/{self.source_id}/files/{quote(ref.key, safe='')}/content",
+            stream=True,
+        )
+        chunks: list[bytes] = []
+        for chunk in response.iter_content(chunk_size=1024 * 1024):
+            if chunk:
+                chunks.append(chunk)
+        return b"".join(chunks), response.headers.get("Content-Type")
+
+    def _external_url(self, key: str) -> str:
+        return f"sandbox://{self.source_id}/{key}"
+
+    def _object_file_name(self, ref: ObjectRef) -> str:
+        metadata = self._file_by_id.get(ref.key, {})
+        return str(metadata.get("fileName") or ref.key)
+
+    def _file_name_for_asset_id(self, asset_id: str) -> str:
+        ref_name = super()._file_name_for_asset_id(asset_id)
+        metadata = self._file_by_id.get(ref_name)
+        return str(metadata.get("fileName") or ref_name) if metadata else ref_name
+
+    def cleanup(self) -> None:
+        self._session.close()
+        super().cleanup()

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/src/utils/embedded_images.py

@@ -5,7 +5,7 @@ standalone assets — e.g. HuggingFace image datasets store an ``image`` column
 ``struct<bytes, path>``, and Office documents embed pictures under their ``media/``
 folders. This module surfaces those images as raw bytes so the scan pipeline can
 treat each one as its own child IMAGE asset (or run image detectors on it directly
-in the sandbox), instead of dumping undecodable bytes into text detectors.
+in file evaluation), instead of dumping undecodable bytes into text detectors.
 
 On any missing optional dependency or parse failure the iterators log a warning and
 yield nothing, so callers degrade gracefully.

{classifyre_cli-0.4.56 → classifyre_cli-0.4.57}/src/utils/file_parser.py

@@ -657,7 +657,7 @@ def parse_bytes(
     """
     Parse in-memory bytes: resolve MIME type and extract raw/text content.
 
-    Used by the sandbox and any caller that needs a complete ParsedBytes in one shot.
+    Used by file evaluation and any caller that needs a complete ParsedBytes in one shot.
     Object-storage sources prefer resolve_mime_type() + iter_file_pages() to avoid
     loading all content into memory before detector scanning.
     """

classifyre_cli-0.4.56/tests/test_sandbox_runner.py → classifyre_cli-0.4.57/tests/test_file_evaluation_runner.py

@@ -1,4 +1,4 @@
-"""Routing tests for SandboxRunner.
+"""Routing tests for FileEvaluationRunner.
 
 Verifies that file-capable detectors (e.g. a vision LLM detector) receive raw
 bytes for images AND PDFs, while text detectors receive extracted text — without
@@ -13,7 +13,7 @@ from typing import Any
 
 import pytest
 
-from src.sandbox.runner import SandboxRunner
+from src.file_evaluation.runner import FileEvaluationRunner
 
 
 class _RecordingDetector:
@@ -40,8 +40,8 @@ _VISION_TYPES = [
 _TEXT_TYPES = ["text/plain", "text/html"]
 
 
-def _runner_with(detector: _RecordingDetector) -> SandboxRunner:
-    runner = SandboxRunner([])
+def _runner_with(detector: _RecordingDetector) -> FileEvaluationRunner:
+    runner = FileEvaluationRunner([])
     runner._build_detectors = lambda: [detector]  # type: ignore[method-assign]
     return runner