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

{classifyre_cli-0.4.45 → classifyre_cli-0.4.47}/.turbo/turbo-build.log

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classifyre-cli
-Version: 0.4.45
+Version: 0.4.47
 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.47}/package.json

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "classifyre-cli"
-version = "0.4.45"
+version = "0.4.47"
 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.47}/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.45 → classifyre_cli-0.4.47}/src/sources/azure_blob_storage/source.py

@@ -111,12 +111,28 @@ class AzureBlobStorageSource(ObjectStorageSourceBase):
 
     def _download_object(self, ref: ObjectRef) -> tuple[bytes, str | None]:
         blob_service_client = self._client()
-        container_client = blob_service_client.get_container_client(self._required_container())
+        container = self._required_container()
+        container_client = blob_service_client.get_container_client(container)
         blob_client = container_client.get_blob_client(ref.key)
 
         timeout = self._request_timeout_seconds()
-        downloader = blob_client.download_blob(offset=0, length=None, timeout=timeout)
+        max_bytes = self._max_object_bytes()
+        # Ranged download: fetch only the capped prefix instead of the whole blob.
+        downloader = blob_client.download_blob(offset=0, length=max_bytes, timeout=timeout)
         file_bytes = downloader.readall()
+
+        if len(file_bytes) > max_bytes:
+            file_bytes = file_bytes[:max_bytes]
+        if ref.size > max_bytes:
+            logger.warning(
+                "Truncated %s/%s/%s to %d of %d bytes for content extraction",
+                self._required_account_url(),
+                container,
+                ref.key,
+                max_bytes,
+                ref.size,
+            )
+
         return file_bytes, ref.content_type_hint
 
     def _external_url(self, key: str) -> str:

{classifyre_cli-0.4.45 → classifyre_cli-0.4.47}/src/sources/google_cloud_storage/source.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import logging
 from collections.abc import Iterator
 from typing import Any
 
@@ -8,6 +9,8 @@ from ...models.generated_input import GoogleCloudStorageInput
 from ..dependencies import require_module
 from ..object_storage.base import ObjectRef, ObjectStorageSourceBase
 
+logger = logging.getLogger(__name__)
+
 
 class GoogleCloudStorageSource(ObjectStorageSourceBase):
     source_type = "google_cloud_storage"
@@ -97,11 +100,26 @@ class GoogleCloudStorageSource(ObjectStorageSourceBase):
 
     def _download_object(self, ref: ObjectRef) -> tuple[bytes, str | None]:
         client = self._client()
-        bucket = client.bucket(self._required_bucket())
+        bucket_name = self._required_bucket()
+        bucket = client.bucket(bucket_name)
         blob = bucket.blob(ref.key)
 
         timeout = self._request_timeout_seconds()
-        file_bytes = blob.download_as_bytes(timeout=timeout)
+        max_bytes = self._max_object_bytes()
+        # Ranged download: fetch only the capped prefix instead of the whole blob.
+        file_bytes = blob.download_as_bytes(start=0, end=max_bytes - 1, timeout=timeout)
+
+        if len(file_bytes) > max_bytes:
+            file_bytes = file_bytes[:max_bytes]
+        if ref.size > max_bytes:
+            logger.warning(
+                "Truncated gs://%s/%s to %d of %d bytes for content extraction",
+                bucket_name,
+                ref.key,
+                max_bytes,
+                ref.size,
+            )
+
         return file_bytes, ref.content_type_hint
 
     def _external_url(self, key: str) -> str:

{classifyre_cli-0.4.45 → classifyre_cli-0.4.47}/src/sources/kafka/source.py

@@ -8,7 +8,11 @@ Sampling strategies map to consumer positioning:
 
 * ``LATEST``    — start near the tail of each partition (newest messages).
 * ``RANDOM``    — start at a random offset within each partition.
-* ``AUTOMATIC`` / ``ALL`` — start at the earliest retained offset.
+* ``ALL``       — start at the earliest retained offset.
+* ``AUTOMATIC`` — resume each partition from a saved per-partition cursor
+  (keyed ``"{topic}:{partition}"``), advancing it each run. Once a
+  partition's cursor catches up to the high watermark it wraps back to the
+  low watermark so the next run re-ingests from the start.
 
 All strategies read up to ``sampling.rows_per_page`` messages per topic.
 """
@@ -302,14 +306,56 @@ class KafkaSource(BaseSource):
             return max(low, high - per)
         if strategy == SamplingStrategy.RANDOM:
             return random.randint(low, max(low, high - per))
-        # AUTOMATIC / ALL: read from the earliest retained offset.
+        # ALL: read from the earliest retained offset.
         return low
 
+    def _automatic_start_offset(self, key: str, low: int, high: int) -> int:
+        """Resume offset for AUTOMATIC sampling, clamped to the retained range.
+
+        Retention may have deleted the previously saved offset (or this may be
+        the first run), in which case we fall back to the earliest retained
+        offset.
+        """
+        saved = self.automatic_offset(key)
+        if saved < low or saved > high:
+            return low
+        return saved
+
+    def _record_automatic_cursors(
+        self,
+        topic: str,
+        messages: list[dict[str, Any]],
+        starts: dict[int, int],
+        watermarks: dict[int, tuple[int, int]],
+    ) -> None:
+        """Advance the per-partition AUTOMATIC cursor after a consume pass.
+
+        Partitions that yielded messages resume from one past the highest
+        offset consumed; partitions that were assigned but yielded nothing
+        keep their (already-clamped) start offset. A partition that has
+        caught up to its high watermark wraps back to the low watermark so
+        the next run re-ingests from the start instead of stalling forever.
+        """
+        consumed_next: dict[int, int] = {}
+        for message in messages:
+            partition_id = int(message["partition"])
+            next_offset = int(message["offset"]) + 1
+            if next_offset > consumed_next.get(partition_id, -1):
+                consumed_next[partition_id] = next_offset
+
+        for partition_id, (low, high) in watermarks.items():
+            next_offset = consumed_next.get(partition_id, starts[partition_id])
+            if next_offset >= high:
+                next_offset = low  # fully caught up: wrap for the next run
+            self._record_cursor_key(f"{topic}:{partition_id}", next_offset)
+
     def _consume(self, topic: str, max_count: int) -> list[dict[str, Any]]:
         strategy = self._sampling().strategy
         consumer = self._make_consumer()
         timeout = self._request_timeout_seconds()
         out: list[dict[str, Any]] = []
+        starts: dict[int, int] = {}
+        watermarks: dict[int, tuple[int, int]] = {}
         try:
             metadata = self._cluster_metadata(consumer, topic)
             topic_meta = metadata.topics.get(topic)
@@ -325,9 +371,17 @@ class KafkaSource(BaseSource):
                 except Exception as exc:
                     logger.debug("Watermark lookup failed for %s[%s]: %s", topic, partition_id, exc)
                     continue
+                low, high = int(low), int(high)
                 if high <= low:
                     continue  # empty partition
-                tp.offset = self._start_offset(strategy, int(low), int(high), per)
+                if strategy == SamplingStrategy.AUTOMATIC:
+                    key = f"{topic}:{partition_id}"
+                    start = self._automatic_start_offset(key, low, high)
+                    starts[partition_id] = start
+                    watermarks[partition_id] = (low, high)
+                else:
+                    start = self._start_offset(strategy, low, high, per)
+                tp.offset = start
                 assignments.append(tp)
             if not assignments:
                 return out
@@ -357,6 +411,10 @@ class KafkaSource(BaseSource):
                         break
         finally:
             consumer.close()
+
+        if strategy == SamplingStrategy.AUTOMATIC and watermarks:
+            self._record_automatic_cursors(topic, out, starts, watermarks)
+
         return out
 
     def _format_messages(

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

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

classifyre_cli-0.4.47/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.45 → classifyre_cli-0.4.47}/src/sources/object_storage/base.py

@@ -211,6 +211,20 @@ class ObjectStorageSourceBase(BaseSource, ABC):
     def _include_content_preview(self) -> bool:
         return bool(self._scope_option("include_content_preview", True))
 
+    # Shared cap across the object-storage family (S3-compatible, GCS, Azure Blob)
+    # so a single huge object can't OOM the scan pod. Mirrors local_folder's
+    # DEFAULT_MAX_FILE_BYTES guard, but sourced from each provider's own
+    # optional.connection.max_object_bytes field (schema default 5MB) when set.
+    DEFAULT_MAX_OBJECT_BYTES = 5 * 1024 * 1024
+
+    def _max_object_bytes(self) -> int:
+        value = self._connection_option("max_object_bytes", self.DEFAULT_MAX_OBJECT_BYTES)
+        try:
+            parsed = int(value)
+        except (TypeError, ValueError):
+            return self.DEFAULT_MAX_OBJECT_BYTES
+        return max(parsed, 1024)
+
     def _normalized_extension_filters(self, key: str) -> list[str]:
         values = self._scope_option(key, [])
         if not isinstance(values, list):

{classifyre_cli-0.4.45 → classifyre_cli-0.4.47}/src/sources/s3_compatible_storage/source.py

@@ -87,17 +87,30 @@ class S3CompatibleStorageSource(ObjectStorageSourceBase):
     def _download_object(self, ref: ObjectRef) -> tuple[bytes, str | None]:
         client = self._client()
         bucket = self._required_bucket()
+        max_bytes = self._max_object_bytes()
 
         response = client.get_object(Bucket=bucket, Key=ref.key)
         body = response["Body"]
         try:
-            file_bytes = body.read()
+            # Read one byte past the cap so we can detect truncation without
+            # ever materializing the full (potentially huge) object body.
+            file_bytes = body.read(max_bytes + 1)
         finally:
             try:
                 body.close()
             except Exception:
                 logger.debug("Failed to close S3 response body")
 
+        if len(file_bytes) > max_bytes:
+            file_bytes = file_bytes[:max_bytes]
+            logger.warning(
+                "Truncated s3://%s/%s to %d of %d bytes for content extraction",
+                bucket,
+                ref.key,
+                max_bytes,
+                ref.size,
+            )
+
         content_type = response.get("ContentType")
         return file_bytes, str(content_type) if content_type else None
 

{classifyre_cli-0.4.45 → classifyre_cli-0.4.47}/src/sources/slack/source.py

@@ -322,10 +322,9 @@ class SlackSource(BaseSource):
         is_automatic = strategy == SamplingStrategy.AUTOMATIC
         if strategy == SamplingStrategy.ALL:
             max_total: int | None = None
-        elif is_automatic:
-            max_total = int(sampling.rows_per_page or 100)
         else:
-            max_total = 100
+            # AUTOMATIC / LATEST / RANDOM all honor the configured window size.
+            max_total = int(sampling.rows_per_page or 100)
         oldest = self._normalize_ts(time_range_options.oldest)
         latest = self._normalize_ts(time_range_options.latest)
         batch_size = min(int(ingestion_options.batch_size or 200), 200)

{classifyre_cli-0.4.45 → classifyre_cli-0.4.47}/src/sources/youtube/source.py

@@ -461,11 +461,11 @@ class YouTubeSource(BaseSource):
             if transcript.available_languages:
                 asset_metadata["caption_tracks"] = transcript.available_languages
 
+        # Checksum must only reflect content changes: view/like counters move on
+        # every re-scan and would flip UNCHANGED assets to UPDATED spuriously.
         checksum_data = {
             "video_id": video_id,
             "title": title,
-            "view_count": asset_metadata.get("view_count"),
-            "like_count": asset_metadata.get("like_count"),
             "transcript_available": asset_metadata["transcript_available"],
         }
 

{classifyre_cli-0.4.45 → classifyre_cli-0.4.47}/tests/test_azure_blob_storage_source.py

@@ -80,3 +80,74 @@ def test_azure_blob_storage_external_url():
         source._external_url("folder/report.csv")
         == "https://acme.blob.core.windows.net/documents/folder/report.csv"
     )
+
+
+class _FakeDownloader:
+    def __init__(self, data: bytes) -> None:
+        self._data = data
+
+    def readall(self) -> bytes:
+        return self._data
+
+
+class _FakeBlobClient:
+    def __init__(self, data: bytes) -> None:
+        self._data = data
+
+    def download_blob(
+        self, offset: int = 0, length: int | None = None, timeout: float | None = None
+    ) -> _FakeDownloader:
+        start = offset or 0
+        end = len(self._data) if length is None else start + length
+        return _FakeDownloader(self._data[start:end])
+
+
+class _FakeContainerClient:
+    def __init__(self, data: bytes) -> None:
+        self._data = data
+
+    def get_blob_client(self, key: str) -> _FakeBlobClient:
+        return _FakeBlobClient(self._data)
+
+
+class _FakeAzureClient:
+    def __init__(self, data: bytes) -> None:
+        self._data = data
+
+    def get_container_client(self, container: str) -> _FakeContainerClient:
+        return _FakeContainerClient(self._data)
+
+
+def test_azure_blob_storage_download_object_truncates_oversized_blob(monkeypatch, caplog):
+    source = AzureBlobStorageSource(
+        {
+            **_recipe(),
+            "optional": {
+                "connection": {"max_object_bytes": 1024},
+                "scope": {"include_content_preview": True},
+            },
+        }
+    )
+    big_bytes = b"z" * 3000
+    monkeypatch.setattr(source, "_client", lambda: _FakeAzureClient(big_bytes))
+    ref = _ref("exports/big.bin", size=len(big_bytes))
+
+    with caplog.at_level("WARNING"):
+        file_bytes, _content_type = source._download_object(ref)
+
+    assert len(file_bytes) == 1024
+    assert any("Truncated" in record.message for record in caplog.records)
+
+
+def test_azure_blob_storage_download_object_leaves_normal_blob_unchanged(monkeypatch, caplog):
+    source = AzureBlobStorageSource(_recipe())
+    small_bytes = b"hello azure"
+    monkeypatch.setattr(source, "_client", lambda: _FakeAzureClient(small_bytes))
+    ref = _ref("exports/small.txt", size=len(small_bytes))
+
+    with caplog.at_level("WARNING"):
+        file_bytes, content_type = source._download_object(ref)
+
+    assert file_bytes == small_bytes
+    assert content_type == "text/plain"
+    assert not any("Truncated" in record.message for record in caplog.records)