classifyre-cli 0.4.80__tar.gz → 0.4.82__tar.gz

classifyre_cli-0.4.82/.turbo/turbo-build.log

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

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/PKG-INFO

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

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/package.json

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

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/pyproject.toml

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

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/src/sources/databricks/source.py

@@ -32,6 +32,7 @@ from ...models.generated_single_asset_scan_results import (
 from ...models.generated_single_asset_scan_results import (
     SingleAssetScanResults,
 )
+from ...utils.file_parser import render_bytes_cell
 from ..dependencies import require_module
 from ..tabular_base import BaseTabularSource
 from ..tabular_utils import TableRef
@@ -418,7 +419,8 @@ class DatabricksSource(BaseTabularSource):
         if value is None:
             return "null"
         if isinstance(value, (bytes, bytearray, memoryview)):
-            return f"<{len(bytes(value))} bytes>"
+            # Text stored in a BINARY column must still reach the detectors.
+            return render_bytes_cell(bytes(value))
         if isinstance(value, datetime):
             return value.isoformat()
         return str(value)

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/src/sources/kafka/source.py

@@ -40,6 +40,7 @@ from ...models.generated_single_asset_scan_results import (
 from ...models.generated_single_asset_scan_results import (
     SingleAssetScanResults,
 )
+from ...utils.file_parser import render_bytes_cell
 from ...utils.hashing import hash_id
 from ..base import BaseSource
 from ..dependencies import require_module
@@ -519,10 +520,10 @@ class KafkaSource(BaseSource):
         if value is None:
             return "null"
         if isinstance(value, (bytes, bytearray)):
-            try:
-                return bytes(value).decode("utf-8")
-            except UnicodeDecodeError:
-                return f"<{len(bytes(value))} bytes>"
+            # A decode that succeeds is not proof of readability: control bytes
+            # are valid UTF-8, so the old UnicodeDecodeError fallback never fired
+            # for a binary payload and emitted raw control characters instead.
+            return render_bytes_cell(bytes(value))
         return str(value)
 
     def _start_offset(self, strategy: SamplingStrategy, low: int, high: int, per: int) -> int:

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/src/sources/mongodb/source.py

@@ -25,6 +25,7 @@ from ...models.generated_single_asset_scan_results import (
     Location,
     SingleAssetScanResults,
 )
+from ...utils.file_parser import json_safe_default
 from ...utils.hashing import hash_id, unhash_id
 from ..base import BaseSource
 from ..dependencies import require_module
@@ -434,7 +435,10 @@ class MongoDBSource(BaseSource):
         )
 
     def _serialize_document(self, document: dict[str, Any]) -> str:
-        return json.dumps(document, ensure_ascii=False, default=str, sort_keys=True)
+        # json_safe_default, not default=str: a BSON Binary subclasses bytes, so
+        # str() renders its Python repr and a JSON payload stored in one arrived
+        # at the detectors doubly escaped instead of as the document it is.
+        return json.dumps(document, ensure_ascii=False, default=json_safe_default, sort_keys=True)
 
     def _format_collection_content(
         self,

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/src/sources/neo4j/source.py

@@ -24,6 +24,7 @@ from ...models.generated_single_asset_scan_results import (
     Location,
     SingleAssetScanResults,
 )
+from ...utils.file_parser import json_safe_default
 from ...utils.hashing import hash_id, unhash_id
 from ..base import BaseSource
 from ..dependencies import require_module
@@ -434,7 +435,9 @@ class Neo4jSource(BaseSource):
         return nodes
 
     def _serialize_node(self, props: dict[str, Any]) -> str:
-        return json.dumps(props, ensure_ascii=False, default=str, sort_keys=True)
+        # Byte-array properties must not fall to str(), which renders
+        # bytearray(b'...') instead of the text the property holds.
+        return json.dumps(props, ensure_ascii=False, default=json_safe_default, sort_keys=True)
 
     def _format_label_content(
         self,

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/src/sources/oracle/source.py

@@ -11,6 +11,7 @@ from ...models.generated_input import (
     SamplingConfig,
     SamplingStrategy,
 )
+from ...utils.file_parser import render_bytes_cell
 from ..dependencies import require_module
 from ..tabular_base import BaseTabularSource
 from ..tabular_utils import TableRef
@@ -244,7 +245,10 @@ class OracleSource(BaseTabularSource):
                 value = str(value)
 
         if isinstance(value, (bytes, bytearray)):
-            return f"<{len(value)} bytes>"
+            # A CLOB read through the LOB branch above lands here as bytes; text in
+            # a BLOB is just as common. Both must stay readable — see
+            # ``render_bytes_cell``.
+            return render_bytes_cell(bytes(value))
         if isinstance(value, datetime):
             return value.isoformat()
         return str(value)

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/src/sources/snowflake/source.py

@@ -21,6 +21,7 @@ from ...models.generated_input import (
     SnowflakeRequiredKeyPairAuthenticator,
     SnowflakeRequiredOauthAuthenticatorToken,
 )
+from ...utils.file_parser import render_bytes_cell
 from ..dependencies import require_module
 from ..tabular_base import BaseTabularSource
 from ..tabular_utils import TableRef
@@ -299,7 +300,8 @@ class SnowflakeSource(BaseTabularSource):
         if isinstance(value, memoryview):
             value = value.tobytes()
         if isinstance(value, (bytes, bytearray)):
-            return f"<{len(value)} bytes>"
+            # Text stored in a BINARY column must still reach the detectors.
+            return render_bytes_cell(bytes(value))
         if isinstance(value, (datetime, date)):
             return value.isoformat()
         if isinstance(value, Decimal):

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/src/sources/tabular_base.py

@@ -28,6 +28,7 @@ from ..models.generated_single_asset_scan_results import (
     SingleAssetScanResults,
 )
 from ..utils.file_metadata import build_columns
+from ..utils.file_parser import render_bytes_cell
 from ..utils.hashing import hash_id, unhash_id
 from .base import BaseSource
 from .tabular_utils import TableRef, build_tabular_location, format_tabular_sample_content
@@ -484,7 +485,11 @@ class BaseTabularSource(BaseSource):
         if isinstance(value, memoryview):
             value = value.tobytes()
         if isinstance(value, (bytes, bytearray)):
-            return f"<{len(value)} bytes>"
+            # BYTEA/BLOB/VARBINARY columns routinely hold text — a JSON payload, an
+            # encoded document, a note written by an ORM that picked the wrong type.
+            # Summarizing them unconditionally meant no detector ever read a byte of
+            # it. Genuinely binary values still summarize.
+            return render_bytes_cell(bytes(value))
         if isinstance(value, datetime):
             return value.isoformat()
         return str(value)

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/src/utils/embedded_files.py

@@ -34,6 +34,7 @@ from .file_parser import (
     _normalize_mime_type,
     _parquet_row_group_start,
     _require_file_processing,
+    is_readable_text,
     resolve_mime_type,
 )
 
@@ -75,29 +76,46 @@ class EmbeddedFile:
     mime_type: str  # resolved from the bytes (and the cell's own path, when it has one)
 
 
+# What a byte-carrying parquet column holds, and therefore how a row renders it.
+CONTENT_FILE = "file"  # a whole file: becomes a child asset, row text gets a placeholder
+CONTENT_TEXT = "text"  # text carried as bytes: decoded straight into the row text
+CONTENT_OPAQUE = "opaque"  # bytes that are not a file and not text: placeholder only
+
+# Markup and data serializations read fine as raw text and belong to their row.
+# Deliberately not here: message/rfc822, which is a real document format the file
+# parser splits into headers and body, so it is worth its own asset.
+_TEXTUAL_MIME_TYPES = frozenset({"application/json", "application/xml", "application/xhtml+xml"})
+
+
 @dataclass(frozen=True)
 class EmbeddedColumn:
-    """A parquet column whose cells hold whole files instead of values."""
+    """A parquet column whose cells hold byte payloads instead of plain values."""
 
     kind: str  # "struct" (a HuggingFace feature: struct<bytes, path>) or "binary"
-    mime_hint: str  # sniffed once from a sample cell; used for row-text placeholders
+    mime_hint: str  # sniffed once from a sample cell
+    content: str  # CONTENT_FILE | CONTENT_TEXT | CONTENT_OPAQUE
 
 
 def is_embeddable_file_mime(mime_type: str) -> bool:
     """Whether sniffed bytes look like a self-contained file worth its own asset.
 
-    Text-shaped payloads are excluded deliberately. A binary column holding JSON or
-    plain text already reads correctly as row text, so promoting it to a child asset
-    would split one record across two assets and scan the same characters twice.
-    Unrecognized bytes are excluded too: a column of embedding vectors or digests is
-    binary without being a file, and each cell must not become an asset.
+    Text-shaped payloads are excluded deliberately: a cell holding JSON or plain
+    text is a *field of its row*, so it is decoded into the row's own text (see
+    ``CONTENT_TEXT``) rather than split off into a second asset. Unrecognized bytes
+    are excluded too — a column of embedding vectors or digests is binary without
+    being a file, and each cell must not become an asset.
     """
+    return classify_embedded_mime(mime_type) == CONTENT_FILE
+
+
+def classify_embedded_mime(mime_type: str) -> str:
+    """Classify sniffed bytes as a file, as text, or as opaque binary."""
     normalized = _normalize_mime_type(mime_type)
     if not normalized or normalized == OCTET_STREAM:
-        return False
-    if normalized.startswith("text/"):
-        return False
-    return normalized not in ("application/json", "application/xml", "application/xhtml+xml")
+        return CONTENT_OPAQUE
+    if normalized.startswith("text/") or normalized in _TEXTUAL_MIME_TYPES:
+        return CONTENT_TEXT
+    return CONTENT_FILE
 
 
 def has_embedded_files(mime_type: str) -> bool:
@@ -164,10 +182,20 @@ def embedded_cell_name(cell: object, kind: str) -> str:
     return ""
 
 
-def detect_parquet_file_columns(parquet_file: Any) -> dict[str, EmbeddedColumn]:
-    """Map column name → ``EmbeddedColumn`` for columns whose cells hold files.
+def detect_parquet_payload_columns(parquet_file: Any) -> dict[str, EmbeddedColumn]:
+    """Map column name → ``EmbeddedColumn`` for every column whose cells hold bytes.
 
-    Returns ``{}`` when pyarrow is unavailable or no such column exists.
+    All of them are returned, classified by what the bytes turned out to be, because
+    each class needs different handling and none of them may fall through to
+    ``str(cell)`` — that renders a Python bytes repr, which is how a column of JSON
+    documents reached the detectors as ``b'{"email": ...}'`` with escaped quotes.
+
+    Classification is per column, sampled once: sniffing every cell of a
+    million-row file would cost more than the scan it feeds. A column of uniform
+    content — the normal case — is therefore classified correctly, and the
+    child-asset path re-checks each cell it emits anyway.
+
+    Returns ``{}`` when pyarrow is unavailable or no column carries bytes.
     """
     try:
         pa = _require_file_processing("pyarrow")
@@ -201,30 +229,41 @@ def detect_parquet_file_columns(parquet_file: Any) -> dict[str, EmbeddedColumn]:
 
     columns: dict[str, EmbeddedColumn] = {}
     for name, kind in candidates:
-        mime = _sample_column_mime(sample, name, kind)
+        mime, sample_bytes = _sample_column_payload(sample, name, kind)
+        content = classify_embedded_mime(mime)
+        # The MIME sniffer falls back to text/plain for bytes it cannot place, so a
+        # column of packed floats or digests arrives labelled as text. Decoding one
+        # would trade a useless repr for a row of invisible control characters.
+        if (
+            content == CONTENT_TEXT
+            and sample_bytes is not None
+            and not is_readable_text(sample_bytes)
+        ):
+            content = CONTENT_OPAQUE
         # A struct<bytes, …> column is a *declared* file feature (HuggingFace Image,
-        # Audio, Video), so it stays a file column even when the sample is empty or
-        # unrecognized. A plain binary column has to prove itself — see
-        # ``is_embeddable_file_mime``.
-        if kind == "struct" or is_embeddable_file_mime(mime):
-            columns[name] = EmbeddedColumn(kind=kind, mime_hint=mime)
+        # Audio, Video), so an unreadable sample still means "file" rather than the
+        # opaque default — the alternative is a declared feature silently rendering
+        # as a placeholder and never being scanned.
+        if content == CONTENT_OPAQUE and kind == "struct" and not mime:
+            content = CONTENT_FILE
+        columns[name] = EmbeddedColumn(kind=kind, mime_hint=mime, content=content)
     return columns
 
 
-def _sample_column_mime(batch: Any, column_name: str, kind: str) -> str:
-    """MIME of the first non-empty cell in the sample batch, or ""."""
+def _sample_column_payload(batch: Any, column_name: str, kind: str) -> tuple[str, bytes | None]:
+    """MIME and bytes of the first non-empty cell in the sample batch."""
     if batch is None:
-        return ""
+        return "", None
     try:
         column = batch.column(column_name)
     except Exception:
-        return ""
+        return "", None
     for index in range(len(column)):
         cell = column[index].as_py()
         raw = extract_embedded_bytes(cell, kind)
         if raw:
-            return resolve_mime_type(raw, file_name=embedded_cell_name(cell, kind))
-    return ""
+            return resolve_mime_type(raw, file_name=embedded_cell_name(cell, kind)), raw
+    return "", None
 
 
 def _iter_parquet_files(
@@ -249,7 +288,14 @@ def _iter_parquet_files(
         logger.warning("Cannot open parquet for embedded-file extraction: %s", exc)
         return
 
-    columns = detect_parquet_file_columns(parquet_file)
+    # Only file-bearing columns produce child assets. A text column is decoded into
+    # its own row's text by the page iterator, so walking it here would scan the
+    # same characters twice under two different asset identities.
+    columns = {
+        name: column
+        for name, column in detect_parquet_payload_columns(parquet_file).items()
+        if column.content == CONTENT_FILE
+    }
     if not columns:
         return
 

{classifyre_cli-0.4.80 → classifyre_cli-0.4.82}/src/utils/file_parser.py

@@ -1064,6 +1064,52 @@ def _decode_bytes(file_bytes: bytes) -> str:
     return decoded.replace("\x00", "")
 
 
+def is_readable_text(raw: bytes) -> bool:
+    """Whether bytes decode to something a text detector could actually read.
+
+    A successful UTF-8 decode is not the test: ``b"\\x01\\x02\\x03"`` decodes
+    cleanly and reads as nothing. What matters is whether the result is mostly
+    printable, which is what separates a UTF-8 document stored in a BLOB from a
+    packed float array stored in the same column type.
+    """
+    sample = raw[:4096]
+    if not sample:
+        return False
+    if b"\x00" in sample:
+        # UTF-16/32 interleaves a NUL with every character and is still text.
+        return _is_null_byte_unicode_text(sample)
+    decoded = sample.decode("utf-8", errors="replace")
+    printable = sum(1 for char in decoded if char.isprintable() or char.isspace())
+    return printable / len(decoded) >= 0.9
+
+
+def render_bytes_cell(raw: bytes) -> str:
+    """Render a byte-valued field as detector-visible text.
+
+    Sources hand rows and documents to text detectors as strings, so every
+    byte-valued field has to become one. The two obvious ways are both wrong:
+    ``str(value)`` emits a Python repr — ``b'{"email": ...}'``, with the prefix,
+    escaped quotes and ``\\n`` spelled out — and a flat ``<N bytes>`` summary drops
+    the content entirely, so text stored in a BLOB is never scanned by anything.
+
+    This decodes what is readable and summarizes only what isn't.
+    """
+    if is_readable_text(raw):
+        return _decode_bytes(raw)
+    return f"<{len(raw)} bytes>"
+
+
+def json_safe_default(value: Any) -> Any:
+    """``json.dumps(default=...)`` that keeps byte fields readable.
+
+    ``default=str`` is the usual choice and it is how a BSON ``Binary`` holding a
+    JSON document reached the detectors as a doubly-escaped repr string.
+    """
+    if isinstance(value, bytes | bytearray | memoryview):
+        return render_bytes_cell(bytes(value))
+    return str(value)
+
+
 def resolve_mime_type(
     file_bytes: bytes,
     *,
@@ -1369,12 +1415,20 @@ def _iter_parquet_pages(
         # (before reading any data) so a bad file can't lock the C++ thread pool.
         pf = pq.ParquetFile(io.BytesIO(file_bytes))  # type: ignore[attr-defined]
 
-        # File columns (HF Image/Audio structs, raw file-byte columns) carry whole
-        # files that are useless and wasteful as row text — they're surfaced
-        # separately as child assets. Render a compact placeholder instead.
-        from .embedded_files import detect_parquet_file_columns, extract_embedded_bytes
+        # Columns whose cells hold bytes never reach str(): that renders a Python
+        # repr, so a column of JSON documents would arrive at the detectors as
+        # b'{"email": ...}' with escaped quotes. Whole files (HF Image/Audio
+        # structs, file-byte columns) render as a placeholder and are scanned
+        # separately as child assets; text carried as bytes is decoded into the row
+        # it belongs to; anything else is summarized rather than spelled out.
+        from .embedded_files import (
+            CONTENT_FILE,
+            CONTENT_TEXT,
+            detect_parquet_payload_columns,
+            extract_embedded_bytes,
+        )
 
-        file_columns = detect_parquet_file_columns(pf)
+        payload_columns = detect_parquet_payload_columns(pf)
 
         begin = max(0, start_row)
         first_group, drop_in_group = _parquet_row_group_start(pf, begin)
@@ -1411,12 +1465,15 @@ def _iter_parquet_pages(
                 lines.append(f"row_{abs_row + 1}:")
                 for col_i, col in enumerate(col_names):
                     cell = batch.column(col_i)[local_idx].as_py()
-                    if col in file_columns:
-                        embedded_column = file_columns[col]
-                        cell_str = _format_embedded_placeholder(
-                            extract_embedded_bytes(cell, embedded_column.kind),
-                            embedded_column.mime_hint,
-                        )
+                    if col in payload_columns:
+                        payload_column = payload_columns[col]
+                        raw = extract_embedded_bytes(cell, payload_column.kind)
+                        if payload_column.content == CONTENT_TEXT:
+                            cell_str = _decode_bytes(raw) if raw else ""
+                        elif payload_column.content == CONTENT_FILE:
+                            cell_str = _format_embedded_placeholder(raw, payload_column.mime_hint)
+                        else:
+                            cell_str = _format_embedded_placeholder(raw, OCTET_STREAM)
                     else:
                         cell_str = "" if cell is None else str(cell)
                     first, *rest = cell_str.splitlines() or [""]
@@ -1470,7 +1527,12 @@ def _format_embedded_placeholder(raw: bytes | None, mime_hint: str = "") -> str:
     The label names what the column holds, since that is the only trace of it left
     in the row text once the child asset carries the content.
     """
-    label = "image" if mime_hint.startswith("image/") else (mime_hint or "file")
+    if mime_hint.startswith("image/"):
+        label = "image"
+    elif not mime_hint or mime_hint == OCTET_STREAM:
+        label = "binary"
+    else:
+        label = mime_hint
     if not raw:
         return f"<{label}>"
     size = len(raw)

classifyre_cli-0.4.82/tests/test_byte_valued_fields.py

@@ -0,0 +1,141 @@
+"""Byte-valued fields must stay readable, whichever source produced them.
+
+Every source hands rows and documents to text detectors as strings, so each one
+has to turn byte-valued fields into text. Two ways of doing that are wrong and
+both were in the tree:
+
+* ``str(value)`` emits a Python repr — ``b'{"email": ...}'`` — so quotes arrive
+  escaped and newlines arrive spelled out as ``\\n``.
+* a flat ``<N bytes>`` summary drops the content, so text stored in a BLOB, a
+  BSON ``Binary`` or a byte-array property was never read by any detector.
+
+These are family-wide guards: the rendering lives in one helper, and a regression
+in it silently blinds every source at once.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from src.utils.file_parser import is_readable_text, json_safe_default, render_bytes_cell
+
+TEXT_DOC = b"Contact Grace at grace@example.com about invoice 4471."
+JSON_DOC = b'{"name": "Ada Lovelace", "email": "ada@example.com"}'
+MULTILINE = b"Dear Grace,\n\nInvoice 4471 is overdue.\nContact ada@example.com\n"
+JUNK = b"\x01\x02\x03\x04\x05\x06"
+PNG_HEADER = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR"
+
+
+# ── The shared helper ────────────────────────────────────────────────────
+
+
+def test_is_readable_text_separates_documents_from_blobs() -> None:
+    assert is_readable_text(TEXT_DOC)
+    assert is_readable_text(JSON_DOC)
+    assert is_readable_text(MULTILINE)
+    # Control bytes decode as valid UTF-8, so a successful decode proves nothing.
+    assert not is_readable_text(JUNK)
+    assert not is_readable_text(PNG_HEADER)
+    assert not is_readable_text(b"")
+
+
+def test_is_readable_text_accepts_utf16() -> None:
+    """UTF-16 interleaves a NUL with every character and is still text."""
+    assert is_readable_text(TEXT_DOC.decode().encode("utf-16"))
+
+
+def test_render_bytes_cell_decodes_text_and_summarizes_binary() -> None:
+    assert render_bytes_cell(TEXT_DOC) == TEXT_DOC.decode()
+    assert render_bytes_cell(JSON_DOC) == JSON_DOC.decode()
+    assert render_bytes_cell(JUNK) == "<6 bytes>"
+    assert render_bytes_cell(b"") == "<0 bytes>"
+
+
+def test_render_bytes_cell_never_emits_a_python_repr() -> None:
+    rendered = render_bytes_cell(MULTILINE)
+    assert not rendered.startswith("b'")
+    assert "\\n" not in rendered  # newlines stayed newlines
+    assert rendered.count("\n") == MULTILINE.decode().count("\n")
+
+
+def test_json_safe_default_keeps_byte_fields_readable() -> None:
+    encoded = json.dumps({"payload": JSON_DOC}, default=json_safe_default)
+    assert json.loads(encoded)["payload"] == JSON_DOC.decode()
+    assert json.loads(json.dumps({"v": JUNK}, default=json_safe_default))["v"] == "<6 bytes>"
+
+
+# ── Per-source wiring ────────────────────────────────────────────────────
+
+
+def test_sql_family_serializes_byte_cells_as_text() -> None:
+    """Covers postgresql, mysql, mssql, sqlite and hive through the shared base."""
+    from src.sources.tabular_base import BaseTabularSource
+
+    serialize = BaseTabularSource._serialize_cell
+    assert serialize(None, JSON_DOC) == JSON_DOC.decode()
+    assert serialize(None, bytearray(TEXT_DOC)) == TEXT_DOC.decode()
+    # psycopg hands BYTEA back as a memoryview.
+    assert serialize(None, memoryview(TEXT_DOC)) == TEXT_DOC.decode()
+    assert serialize(None, JUNK) == "<6 bytes>"
+    assert serialize(None, None) == "null"
+
+
+@pytest.mark.parametrize(
+    ("module_path", "class_name"),
+    [
+        ("src.sources.oracle.source", "OracleSource"),
+        ("src.sources.databricks.source", "DatabricksSource"),
+        ("src.sources.snowflake.source", "SnowflakeSource"),
+    ],
+)
+def test_dialect_overrides_serialize_byte_cells_as_text(module_path: str, class_name: str) -> None:
+    """These three override _serialize_cell, so the base fix does not reach them."""
+    module = pytest.importorskip(module_path)
+    source_class = getattr(module, class_name)
+
+    assert source_class._serialize_cell(None, TEXT_DOC) == TEXT_DOC.decode()
+    assert source_class._serialize_cell(None, JUNK) == "<6 bytes>"
+
+
+def test_mongodb_binary_field_is_not_a_repr() -> None:
+    """A BSON Binary subclasses bytes, so default=str rendered its repr.
+
+    Asserted on plain bytes so the guard runs without pymongo installed — that is
+    the same branch ``json_safe_default`` takes for a ``Binary`` — and again on a
+    real ``Binary`` wherever the optional driver is available.
+    """
+    from src.sources.mongodb.source import MongoDBSource
+
+    payloads = [JSON_DOC]
+    try:
+        from bson import Binary
+
+        payloads.append(Binary(JSON_DOC))
+    except ImportError:
+        pass
+
+    for payload in payloads:
+        document = json.loads(MongoDBSource._serialize_document(None, {"payload": payload}))
+        assert document["payload"] == JSON_DOC.decode()
+        assert "b'" not in document["payload"]
+
+
+def test_neo4j_byte_array_property_is_not_a_repr() -> None:
+    from src.sources.neo4j.source import Neo4jSource
+
+    node = json.loads(Neo4jSource._serialize_node(None, {"blob": bytearray(TEXT_DOC)}))
+
+    assert node["blob"] == TEXT_DOC.decode()
+    assert "bytearray(" not in node["blob"]
+
+
+def test_kafka_summarizes_binary_payloads_instead_of_control_characters() -> None:
+    """Regression: the old UnicodeDecodeError fallback never fired for control
+    bytes, which are valid UTF-8, so binary messages emitted raw control chars."""
+    from src.sources.kafka.source import KafkaSource
+
+    assert KafkaSource._decode(TEXT_DOC) == TEXT_DOC.decode()
+    assert KafkaSource._decode(JUNK) == "<6 bytes>"
+    assert KafkaSource._decode(None) == "null"