classifyre-cli 0.4.45__tar.gz → 0.4.46__tar.gz

classifyre_cli-0.4.46/.turbo/turbo-build.log

@@ -0,0 +1,3 @@
+$ uv sync
+Resolved 276 packages in 246ms
+Checked 51 packages in 0.99ms

{classifyre_cli-0.4.45 → classifyre_cli-0.4.46}/PKG-INFO

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

{classifyre_cli-0.4.45 → classifyre_cli-0.4.46}/package.json

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

{classifyre_cli-0.4.45 → classifyre_cli-0.4.46}/pyproject.toml

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

{classifyre_cli-0.4.45 → classifyre_cli-0.4.46}/src/models/generated_input.py

@@ -51,6 +51,7 @@ class AssetType(StrEnum):
     ELASTICSEARCH = 'ELASTICSEARCH'
     OPENSEARCH = 'OPENSEARCH'
     MEILISEARCH = 'MEILISEARCH'
+    LOCAL_FOLDER = 'LOCAL_FOLDER'
 
 
 class DetectorType(StrEnum):
@@ -355,6 +356,7 @@ class Type(StrEnum):
     ELASTICSEARCH = 'ELASTICSEARCH'
     OPENSEARCH = 'OPENSEARCH'
     MEILISEARCH = 'MEILISEARCH'
+    LOCAL_FOLDER = 'LOCAL_FOLDER'
 
 
 class YouTubeRequired(BaseModel):
@@ -644,6 +646,64 @@ class S3CompatibleStorageOptional(BaseModel):
     scope: ObjectStorageOptionalScope | None = None
 
 
+class LocalFolderRequired(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    path: str = Field(
+        ...,
+        description='Absolute path of the local folder to scan (for example, /Users/jane/Documents)',
+    )
+
+
+class LocalFolderMasked(BaseModel):
+    """
+    Local folder scans run with the desktop application's filesystem permissions; no credentials are required.
+    """
+
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+
+
+class LocalFolderOptionalTraversal(BaseModel):
+    """
+    Directory traversal controls.
+    """
+
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    follow_symlinks: bool | None = Field(
+        False,
+        description='Follow symbolic links while traversing (loops are not detected; leave off unless needed)',
+    )
+    include_hidden: bool | None = Field(
+        False,
+        description='Include hidden files and dot-directories (names starting with a dot)',
+    )
+    max_depth: int | None = Field(
+        None,
+        description='Maximum directory depth below the selected folder (unset scans all levels)',
+        ge=1,
+        le=64,
+    )
+    max_file_bytes: int | None = Field(
+        10485760,
+        description='Maximum bytes read per file for MIME detection and text extraction',
+        ge=1024,
+        le=104857600,
+    )
+
+
+class LocalFolderOptional(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    traversal: LocalFolderOptionalTraversal | None = None
+    scope: ObjectStorageOptionalScope | None = None
+
+
 class AzureBlobStorageRequired(BaseModel):
     model_config = ConfigDict(
         extra='forbid',
@@ -2100,6 +2160,24 @@ class S3CompatibleStorageInput(CoreInput):
     resources: ResourceOverrides | None = None
 
 
+class LocalFolderInput(CoreInput):
+    type: Literal['LOCAL_FOLDER'] | None = Field(
+        None, description='Type of the asset or source'
+    )
+    required: LocalFolderRequired
+    masked: LocalFolderMasked | None = None
+    optional: LocalFolderOptional | 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'
@@ -2531,7 +2609,7 @@ class ConfluenceOptionalConnection(BaseModel):
     )
 
 
-class Type18(StrEnum):
+class Type19(StrEnum):
     """
     Filter spaces by space type
     """
@@ -2568,7 +2646,7 @@ class ConfluenceOptionalScopeSpaces(BaseModel):
     keys: list[str] | None = Field(
         None, description='Filter spaces by keys (up to 250)', max_length=250
     )
-    type: Type18 | None = Field(None, description='Filter spaces by space type')
+    type: Type19 | 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,
@@ -2834,7 +2912,7 @@ class ServiceDeskOptional(BaseModel):
     content: ServiceDeskOptionalContent | None = None
 
 
-class Type19(StrEnum):
+class Type20(StrEnum):
     """
     Type of the asset or source
     """
@@ -2868,6 +2946,7 @@ class Type19(StrEnum):
     ELASTICSEARCH = 'ELASTICSEARCH'
     OPENSEARCH = 'OPENSEARCH'
     MEILISEARCH = 'MEILISEARCH'
+    LOCAL_FOLDER = 'LOCAL_FOLDER'
 
 
 class ConfluenceInput(CoreInput):
@@ -3682,6 +3761,7 @@ class SourceInput(
     RootModel[
         SlackInput
         | S3CompatibleStorageInput
+        | LocalFolderInput
         | AzureBlobStorageInput
         | GoogleCloudStorageInput
         | PostgreSQLInput
@@ -3714,6 +3794,7 @@ class SourceInput(
     root: (
         SlackInput
         | S3CompatibleStorageInput
+        | LocalFolderInput
         | AzureBlobStorageInput
         | GoogleCloudStorageInput
         | PostgreSQLInput

classifyre_cli-0.4.46/src/sources/local_folder/__init__.py

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

classifyre_cli-0.4.46/src/sources/local_folder/source.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Iterator
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+from ...models.generated_input import LocalFolderInput
+from ..object_storage.base import ObjectRef, ObjectStorageSourceBase
+
+logger = logging.getLogger(__name__)
+
+
+class LocalFolderSource(ObjectStorageSourceBase):
+    """Scans a folder on the local filesystem (desktop application deployments).
+
+    Reuses the object-storage pipeline: each file becomes an ObjectRef whose key
+    is the path relative to the scanned root, so sampling, MIME resolution, text
+    extraction, file metadata, and embedded-image child assets all come from
+    ObjectStorageSourceBase.
+    """
+
+    source_type = "local_folder"
+    provider_label = "LOCAL_FOLDER"
+    input_model = LocalFolderInput
+
+    DEFAULT_MAX_FILE_BYTES = 10 * 1024 * 1024
+
+    _resolved_root: Path | None = None
+
+    def _root(self) -> Path:
+        if self._resolved_root is not None:
+            return self._resolved_root
+        raw = str(self.config.required.path).strip()
+        if not raw:
+            raise ValueError("required.path must be set")
+        root = Path(raw).expanduser()
+        if not root.is_absolute():
+            raise ValueError(f"required.path must be an absolute path, got: {raw}")
+        if not root.exists():
+            raise ValueError(f"Folder does not exist: {root}")
+        if not root.is_dir():
+            raise ValueError(f"Path is not a folder: {root}")
+        self._resolved_root = root.resolve()
+        return self._resolved_root
+
+    def _traversal_option(self, key: str, default: Any = None) -> Any:
+        optional = self.config.optional
+        traversal = getattr(optional, "traversal", None) if optional else None
+        if traversal is not None:
+            value = getattr(traversal, key, None)
+            if value is not None:
+                return value
+        return default
+
+    def _follow_symlinks(self) -> bool:
+        return bool(self._traversal_option("follow_symlinks", False))
+
+    def _include_hidden(self) -> bool:
+        return bool(self._traversal_option("include_hidden", False))
+
+    def _max_depth(self) -> int | None:
+        value = self._traversal_option("max_depth")
+        try:
+            return int(value) if value is not None else None
+        except (TypeError, ValueError):
+            return None
+
+    def _max_file_bytes(self) -> int:
+        value = self._traversal_option("max_file_bytes", self.DEFAULT_MAX_FILE_BYTES)
+        try:
+            parsed = int(value)
+        except (TypeError, ValueError):
+            return self.DEFAULT_MAX_FILE_BYTES
+        return max(parsed, 1024)
+
+    def _is_hidden(self, name: str) -> bool:
+        return name.startswith(".")
+
+    def _walk(self, directory: Path, depth: int) -> Iterator[ObjectRef]:
+        max_depth = self._max_depth()
+        follow_symlinks = self._follow_symlinks()
+        include_hidden = self._include_hidden()
+
+        try:
+            entries = sorted(os.scandir(directory), key=lambda entry: entry.name)
+        except OSError as exc:
+            logger.warning("Skipping unreadable directory %s: %s", directory, exc)
+            return
+
+        for entry in entries:
+            if not include_hidden and self._is_hidden(entry.name):
+                continue
+            try:
+                if entry.is_dir(follow_symlinks=follow_symlinks):
+                    if max_depth is None or depth < max_depth:
+                        yield from self._walk(Path(entry.path), depth + 1)
+                    continue
+                if not entry.is_file(follow_symlinks=follow_symlinks):
+                    continue
+                stat = entry.stat(follow_symlinks=follow_symlinks)
+            except OSError as exc:
+                logger.warning("Skipping unreadable entry %s: %s", entry.path, exc)
+                continue
+
+            key = Path(entry.path).relative_to(self._root()).as_posix()
+            if not self._object_matches_extension_filters(key):
+                continue
+            prefix = self._prefix()
+            if prefix and not key.startswith(prefix):
+                continue
+            if stat.st_size == 0 and not self._include_empty_objects():
+                continue
+
+            yield ObjectRef(
+                key=key,
+                size=stat.st_size,
+                last_modified=datetime.fromtimestamp(stat.st_mtime, tz=UTC),
+                # Change signature: mtime+size, so edits produce a new checksum
+                # without hashing file bytes during discovery.
+                etag=f"{stat.st_mtime_ns:x}-{stat.st_size:x}",
+            )
+
+    def _list_objects(self) -> Iterator[ObjectRef]:
+        yield from self._walk(self._root(), depth=0)
+
+    def _download_object(self, ref: ObjectRef) -> tuple[bytes, str | None]:
+        file_path = self._root() / ref.key
+        max_bytes = self._max_file_bytes()
+        with open(file_path, "rb") as handle:
+            file_bytes = handle.read(max_bytes)
+        if ref.size > max_bytes:
+            logger.info(
+                "Truncated %s to %d of %d bytes for content extraction",
+                file_path,
+                max_bytes,
+                ref.size,
+            )
+        return file_bytes, None
+
+    def _external_url(self, key: str) -> str:
+        absolute = (self._root() / key).as_posix()
+        return f"file://{quote(absolute)}"

classifyre_cli-0.4.46/tests/test_local_folder_source.py

@@ -0,0 +1,335 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+from src.models.generated_single_asset_scan_results import AssetType as OutputAssetType
+from src.sources.local_folder.source import LocalFolderSource
+
+# Minimal valid 1x1 PNG (8-byte signature + IHDR/IDAT/IEND chunks).
+_PNG_BYTES = bytes.fromhex(
+    "89504e470d0a1a0a0000000d494844520000000100000001080600000"
+    "01f15c4890000000a49444154789c6300010000050001a5f645400000000049454e44ae426082"
+)
+
+
+def _recipe(path: Path, *, optional: dict | None = None, sampling: dict | None = None) -> dict:
+    return {
+        "type": "LOCAL_FOLDER",
+        "required": {"path": str(path)},
+        "masked": {},
+        "optional": optional or {},
+        "sampling": sampling or {"strategy": "ALL"},
+    }
+
+
+def _make_source(path: Path, *, optional: dict | None = None, sampling: dict | None = None):
+    return LocalFolderSource(
+        _recipe(path, optional=optional, sampling=sampling),
+        source_id="s",
+        runner_id="r",
+    )
+
+
+async def _extract_assets(source: LocalFolderSource) -> list:
+    assets = []
+    async for batch in source.extract_raw():
+        assets.extend(batch)
+    return assets
+
+
+def _keys(assets: list) -> set[str]:
+    return {a.metadata["object_key"] for a in assets}
+
+
+# ---------------------------------------------------------------------------
+# 1. Nested traversal
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_nested_traversal_returns_posix_relative_keys(tmp_path: Path):
+    (tmp_path / "top.txt").write_text("top level")
+    nested_dir = tmp_path / "a" / "b"
+    nested_dir.mkdir(parents=True)
+    (nested_dir / "deep.txt").write_text("deep file")
+
+    source = _make_source(tmp_path)
+    assets = await _extract_assets(source)
+
+    assert _keys(assets) == {"top.txt", "a/b/deep.txt"}
+    names = {a.name for a in assets}
+    assert names == {"top.txt", "deep.txt"}
+
+
+# ---------------------------------------------------------------------------
+# 2. Hidden files/dirs
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_hidden_files_skipped_by_default(tmp_path: Path):
+    (tmp_path / "visible.txt").write_text("visible")
+    (tmp_path / ".hidden.txt").write_text("hidden")
+    hidden_dir = tmp_path / ".hiddendir"
+    hidden_dir.mkdir()
+    (hidden_dir / "inside.txt").write_text("inside hidden dir")
+
+    source = _make_source(tmp_path)
+    assets = await _extract_assets(source)
+
+    assert _keys(assets) == {"visible.txt"}
+
+
+@pytest.mark.asyncio
+async def test_hidden_files_included_when_configured(tmp_path: Path):
+    (tmp_path / "visible.txt").write_text("visible")
+    (tmp_path / ".hidden.txt").write_text("hidden")
+    hidden_dir = tmp_path / ".hiddendir"
+    hidden_dir.mkdir()
+    (hidden_dir / "inside.txt").write_text("inside hidden dir")
+
+    source = _make_source(tmp_path, optional={"traversal": {"include_hidden": True}})
+    assets = await _extract_assets(source)
+
+    assert _keys(assets) == {"visible.txt", ".hidden.txt", ".hiddendir/inside.txt"}
+
+
+# ---------------------------------------------------------------------------
+# 3. include/exclude extensions
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_include_extensions_filters_to_allowlist(tmp_path: Path):
+    (tmp_path / "a.txt").write_text("a")
+    (tmp_path / "b.csv").write_text("b,c\n1,2\n")
+    (tmp_path / "c.md").write_text("# markdown")
+
+    source = _make_source(tmp_path, optional={"scope": {"include_extensions": [".txt", ".csv"]}})
+    assets = await _extract_assets(source)
+
+    assert _keys(assets) == {"a.txt", "b.csv"}
+
+
+@pytest.mark.asyncio
+async def test_exclude_extensions_filters_out_denylist(tmp_path: Path):
+    (tmp_path / "a.txt").write_text("a")
+    (tmp_path / "b.csv").write_text("b,c\n1,2\n")
+    (tmp_path / "c.md").write_text("# markdown")
+
+    source = _make_source(tmp_path, optional={"scope": {"exclude_extensions": [".md"]}})
+    assets = await _extract_assets(source)
+
+    assert _keys(assets) == {"a.txt", "b.csv"}
+
+
+# ---------------------------------------------------------------------------
+# 4. Empty files
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_empty_files_skipped_by_default(tmp_path: Path):
+    (tmp_path / "empty.txt").touch()
+    (tmp_path / "nonempty.txt").write_text("content")
+
+    source = _make_source(tmp_path)
+    assets = await _extract_assets(source)
+
+    assert _keys(assets) == {"nonempty.txt"}
+
+
+@pytest.mark.asyncio
+async def test_empty_files_included_when_configured(tmp_path: Path):
+    (tmp_path / "empty.txt").touch()
+    (tmp_path / "nonempty.txt").write_text("content")
+
+    source = _make_source(tmp_path, optional={"scope": {"include_empty_objects": True}})
+    assets = await _extract_assets(source)
+
+    assert _keys(assets) == {"empty.txt", "nonempty.txt"}
+
+
+# ---------------------------------------------------------------------------
+# 5. max_depth
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_max_depth_limits_recursion(tmp_path: Path):
+    (tmp_path / "root.txt").write_text("root")
+    level1 = tmp_path / "l1"
+    level1.mkdir()
+    (level1 / "one.txt").write_text("one")
+    level2 = level1 / "l2"
+    level2.mkdir()
+    (level2 / "two.txt").write_text("two")
+
+    source = _make_source(tmp_path, optional={"traversal": {"max_depth": 1}})
+    assets = await _extract_assets(source)
+
+    assert _keys(assets) == {"root.txt", "l1/one.txt"}
+
+
+# ---------------------------------------------------------------------------
+# 6. max_file_bytes truncation
+# ---------------------------------------------------------------------------
+
+
+def test_download_object_truncates_to_max_file_bytes(tmp_path: Path):
+    big_file = tmp_path / "big.bin"
+    big_file.write_bytes(b"x" * 3000)
+
+    source = _make_source(tmp_path, optional={"traversal": {"max_file_bytes": 1024}})
+    refs = list(source._list_objects())
+    assert len(refs) == 1
+
+    file_bytes, content_type_hint = source._download_object(refs[0])
+
+    assert len(file_bytes) == 1024
+    assert content_type_hint is None
+
+
+# ---------------------------------------------------------------------------
+# 7. external_url / hash determinism / etag & checksum change on edit
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_external_url_and_hash_determinism(tmp_path: Path):
+    file_path = tmp_path / "note.txt"
+    file_path.write_text("hello")
+
+    source_a = _make_source(tmp_path)
+    assets_a = await _extract_assets(source_a)
+    assert len(assets_a) == 1
+    asset_a = assets_a[0]
+
+    assert asset_a.external_url.startswith("file://")
+    assert asset_a.external_url == f"file://{file_path.resolve().as_posix()}"
+
+    source_b = _make_source(tmp_path)
+    assets_b = await _extract_assets(source_b)
+    asset_b = assets_b[0]
+
+    assert asset_a.hash == asset_b.hash
+
+
+@pytest.mark.asyncio
+async def test_etag_and_checksum_change_on_content_and_mtime_change(tmp_path: Path):
+    file_path = tmp_path / "note.txt"
+    file_path.write_text("hello")
+    os.utime(file_path, (1_700_000_000, 1_700_000_000))
+
+    source_before = _make_source(tmp_path)
+    assets_before = await _extract_assets(source_before)
+    asset_before = assets_before[0]
+
+    file_path.write_text("hello world, now longer")
+    os.utime(file_path, (1_700_001_000, 1_700_001_000))
+
+    source_after = _make_source(tmp_path)
+    assets_after = await _extract_assets(source_after)
+    asset_after = assets_after[0]
+
+    # Hash is derived from the (unchanged) external_url/key, so it stays stable...
+    assert asset_before.hash == asset_after.hash
+    # ...but the etag (mtime+size signature) and checksum must reflect the edit.
+    assert asset_before.metadata["etag"] != asset_after.metadata["etag"]
+    assert asset_before.checksum != asset_after.checksum
+
+
+# ---------------------------------------------------------------------------
+# 8. asset_type mapping
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_asset_type_mapping_by_extension(tmp_path: Path):
+    (tmp_path / "doc.txt").write_text("plain text")
+    (tmp_path / "table.csv").write_text("a,b\n1,2\n")
+    (tmp_path / "image.png").write_bytes(_PNG_BYTES)
+
+    source = _make_source(tmp_path)
+    assets = await _extract_assets(source)
+    by_key = {a.metadata["object_key"]: a for a in assets}
+
+    assert by_key["doc.txt"].asset_type == OutputAssetType.TXT
+    assert by_key["table.csv"].asset_type == OutputAssetType.TABLE
+    assert by_key["image.png"].asset_type == OutputAssetType.IMAGE
+    assert by_key["image.png"].asset_kind == "image"
+
+
+# ---------------------------------------------------------------------------
+# 9. Metadata contract (asset_kind + catalog-validated metadata)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_metadata_contract_for_file_asset(tmp_path: Path):
+    (tmp_path / "doc.txt").write_text("plain text")
+
+    source = _make_source(tmp_path)
+    assets = await _extract_assets(source)
+    asset = assets[0]
+
+    assert asset.asset_kind == "file"
+    assert asset.metadata["provider"] == "LOCAL_FOLDER"
+    assert asset.metadata["object_key"] == "doc.txt"
+    assert asset.metadata["size_bytes"] == len("plain text")
+    assert "mime_type" in asset.metadata
+
+
+# ---------------------------------------------------------------------------
+# 10. test_connection
+# ---------------------------------------------------------------------------
+
+
+def test_connection_success_for_valid_directory(tmp_path: Path):
+    (tmp_path / "a.txt").write_text("a")
+
+    source = _make_source(tmp_path)
+    result = source.test_connection()
+
+    assert result["status"] == "SUCCESS"
+
+
+def test_connection_failure_for_missing_directory(tmp_path: Path):
+    missing = tmp_path / "does-not-exist"
+
+    source = _make_source(missing)
+    result = source.test_connection()
+
+    assert result["status"] == "FAILURE"
+
+
+# ---------------------------------------------------------------------------
+# 11. Sampling
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_sampling_random_respects_rows_per_page(tmp_path: Path):
+    # SamplingConfig.rows_per_page has a hard floor of 10 (ge=10), so exercise the
+    # floor value against a larger population rather than requesting 1 row.
+    for i in range(15):
+        (tmp_path / f"file{i}.txt").write_text(f"content {i}")
+
+    source = _make_source(tmp_path, sampling={"strategy": "RANDOM", "rows_per_page": 10})
+    assets = await _extract_assets(source)
+
+    assert len(assets) == 10
+
+
+@pytest.mark.asyncio
+async def test_sampling_latest_respects_rows_per_page(tmp_path: Path):
+    for i in range(15):
+        (tmp_path / f"file{i}.txt").write_text(f"content {i}")
+
+    source = _make_source(tmp_path, sampling={"strategy": "LATEST", "rows_per_page": 10})
+    assets = await _extract_assets(source)
+
+    assert len(assets) == 10

{classifyre_cli-0.4.45 → classifyre_cli-0.4.46}/uv.lock

@@ -721,7 +721,7 @@ wheels = [
 
 [[package]]
 name = "classifyre-cli"
-version = "0.4.45"
+version = "0.4.46"
 source = { editable = "." }
 dependencies = [
     { name = "beautifulsoup4" },
@@ -1151,7 +1151,7 @@ youtube = [
 
 [[package]]
 name = "classifyre-schemas"
-version = "0.4.45"
+version = "0.4.46"
 source = { editable = "../../packages/schemas" }
 dependencies = [
     { name = "fastjsonschema" },

classifyre_cli-0.4.45/.turbo/turbo-build.log

@@ -1,3 +0,0 @@
-$ uv sync
-Resolved 276 packages in 177ms
-Checked 51 packages in 1ms