classifyre-cli 0.7.0__tar.gz → 0.7.1__tar.gz

classifyre_cli-0.7.1/.turbo/turbo-build.log

@@ -0,0 +1,3 @@
+$ uv sync
+Resolved 325 packages in 329ms
+Checked 52 packages in 4ms

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/PKG-INFO

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

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/package.json

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

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "classifyre-cli"
-version = "0.7.0"
+version = "0.7.1"
 description = "Classifyre CLI — scan and classify unstructured data sources"
 readme = "README.md"
 # Upper bound is load-bearing: onnxruntime publishes no cp315 wheels (notably

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/src/main.py

@@ -971,6 +971,11 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
                             source.partial_coverage_reason or "no reason given",
                         )
 
+                    if getattr(source, "listing_complete", False) and hasattr(
+                        sink, "set_listing_complete"
+                    ):
+                        sink.set_listing_complete()
+
                     # Relationships go *before* finish(): finish() finalizes the
                     # run and marks it COMPLETED, and edges that land after that
                     # belong to a run that already claimed to be done.

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/src/outputs/rest.py

@@ -203,6 +203,7 @@ class FinalizeIngestRunRequest(BaseModel):
     # "This run covered a slice of the source." Suppresses retirement: absence
     # from a cohort run is not evidence that an asset is gone.
     partial_coverage: bool | None = Field(None, serialization_alias="partialCoverage")
+    discovery_complete: bool | None = Field(None, serialization_alias="discoveryComplete")
     # Per ctx.cohort(): keys each band visited, and the weights it ran with.
     cohort_stats: dict[str, Any] | None = Field(None, serialization_alias="cohortStats")
     # Detectors the circuit breaker disabled mid-run (scan-cache identity
@@ -261,6 +262,7 @@ class RestOutputSink:
         self._scan_cache_savings: tuple[int, int] | None = None
         self._partial_coverage: bool = False
         self._partial_coverage_reason: str = ""
+        self._listing_complete: bool = False
         self._detectors_degraded: list[str] = []
         self._cohort_stats: dict[str, Any] | None = None
         self.relationship_report = RelationshipReport()
@@ -279,6 +281,10 @@ class RestOutputSink:
         if reason:
             self._partial_coverage_reason = str(reason)
 
+    def set_listing_complete(self) -> None:
+        """Mark that discovery named every object of the configured scope."""
+        self._listing_complete = True
+
     def set_detectors_degraded(self, keys: list[str]) -> None:
         """Record detectors the breaker disabled mid-run, for the next run's sweep."""
         seen: set[str] = set(self._detectors_degraded)
@@ -415,6 +421,7 @@ class RestOutputSink:
             relationships_dropped=lineage.dropped,
             relationship_errors=lineage.errors or None,
             partial_coverage=True if self._partial_coverage else None,
+            discovery_complete=True if self._listing_complete else None,
             cohort_stats=self._cohort_stats,
             detectors_degraded=self._detectors_degraded or None,
         )

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/src/sources/base.py

@@ -89,6 +89,8 @@ class BaseSource(ABC):
         self._next_sampling_cursor: dict[str, Any] | None = None
         self._partial_coverage: bool = False
         self._partial_coverage_reason: str = ""
+        self._listing_complete: bool = False
+        self._listing_errors: int = 0
         self._sampling_cursor_lock = threading.Lock()
         self._apply_initial_sampling_override(normalized_recipe)
         recipe.clear()
@@ -191,6 +193,34 @@ class BaseSource(ABC):
         if reason and not self._partial_coverage_reason:
             self._partial_coverage_reason = str(reason)
 
+    def note_listing_error(self) -> None:
+        """Record that part of the catalog could not be listed this run.
+
+        A listing that skipped a schema, a folder or a label cannot say that
+        what it did not list is gone, so it forfeits :meth:`declare_listing_complete`.
+        """
+        self._listing_errors = getattr(self, "_listing_errors", 0) + 1
+
+    def declare_listing_complete(self) -> None:
+        """Say that discovery named every object of the configured scope.
+
+        Sampling decides how much of each asset is read, not which assets
+        exist. A catalog connector (tables, node labels) lists its whole scope
+        on every run whatever the strategy, so an asset missing from that list
+        is gone and can be retired -- without this, only strategy=ALL ever
+        retired anything and every other source kept deleted tables, moved
+        databases and renamed labels as "unchanged" forever.
+
+        Ignored when any part of the listing failed or the run declared partial
+        coverage.
+        """
+        if getattr(self, "_listing_errors", 0) == 0:
+            self._listing_complete = True
+
+    @property
+    def listing_complete(self) -> bool:
+        return bool(getattr(self, "_listing_complete", False)) and not self.partial_coverage
+
     @property
     def partial_coverage(self) -> bool:
         return bool(getattr(self, "_partial_coverage", False))

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/src/sources/databricks/source.py

@@ -109,6 +109,9 @@ class DatabricksSource(BaseTabularSource):
         self._validate_auth_configuration()
 
         self.session = requests.Session()
+        # table_key -> upstream table -> ids of the notebooks Unity Catalog saw
+        # move data between the two. Filled by _lineage_refs_for_table.
+        self._lineage_notebook_ids: dict[tuple[str, ...], dict[tuple[str, str, str], set[str]]] = {}
         self._access_token: str | None = None
         self._access_token_expiry: datetime | None = None
 
@@ -409,9 +412,13 @@ class DatabricksSource(BaseTabularSource):
         without_scheme = raw.split("://", 1)[-1]
         return without_scheme.strip("/").split("/", 1)[0]
 
-    def _available_columns(self, table_ref: TableRef) -> list[str]:
+    def _available_column_types(self, table_ref: TableRef) -> dict[str, str]:
+        # ``system.information_schema`` sees every catalog from one connection;
+        # the default query reads only the connection's current catalog and a
+        # parameter style Databricks does not take, so types used to come back
+        # empty for every column.
         query = (
-            "SELECT column_name "
+            "SELECT column_name, COALESCE(full_data_type, data_type) "
             "FROM system.information_schema.columns "
             f"WHERE table_catalog = {_quote_literal(table_ref.database)} "
             f"AND table_schema = {_quote_literal(table_ref.schema or '')} "
@@ -421,17 +428,17 @@ class DatabricksSource(BaseTabularSource):
         conn = self._get_cached_connection(table_ref.database)
         with conn.cursor() as cursor:
             cursor.execute(query)
-            columns: list[str] = []
+            columns: dict[str, str] = {}
             for row in cursor.fetchall():
-                candidate: Any | None = None
-                try:
-                    candidate = row[0]  # type: ignore[index]
-                except Exception:
-                    candidate = None
-                if isinstance(candidate, str):
-                    columns.append(candidate)
+                name = row[0] if len(row) > 0 else None
+                if isinstance(name, str):
+                    data_type = row[1] if len(row) > 1 else None
+                    columns[name] = str(data_type) if data_type is not None else ""
             return columns
 
+    def _available_columns(self, table_ref: TableRef) -> list[str]:
+        return list(self._available_column_types(table_ref))
+
     # ── Databricks-specific cell serialization ───────────────────────────
 
     def _serialize_cell(self, value: Any) -> str:
@@ -598,6 +605,7 @@ class DatabricksSource(BaseTabularSource):
         try:
             schemas = self._list_schemas_for_catalog(database)
         except Exception as exc:
+            self.note_listing_error()
             logger.warning("Skipping catalog %s due to schema listing error: %s", database, exc)
             return tables
         for schema in schemas:
@@ -606,6 +614,7 @@ class DatabricksSource(BaseTabularSource):
             try:
                 tables.extend(self._list_tables_for_schema(database, schema))
             except Exception as exc:
+                self.note_listing_error()
                 logger.warning(
                     "Skipping schema %s.%s due to table listing error: %s",
                     database,
@@ -653,6 +662,7 @@ class DatabricksSource(BaseTabularSource):
             },
         )
         refs: set[tuple[str, str, str]] = set()
+        notebooks: dict[tuple[str, str, str], set[str]] = {}
         for key in ("upstreams", "upstream_tables"):
             entries = response.get(key)
             if isinstance(entries, list):
@@ -661,6 +671,12 @@ class DatabricksSource(BaseTabularSource):
                         parsed = self._lineage_table_ref_from_payload(entry)
                         if parsed:
                             refs.add(parsed)
+                            for info in entry.get("notebookInfos") or []:
+                                if isinstance(info, dict) and info.get("notebook_id") is not None:
+                                    notebooks.setdefault(parsed, set()).add(
+                                        str(info["notebook_id"])
+                                    )
+        self._lineage_notebook_ids[table_ref.table_key] = notebooks
         return refs
 
     def _emit_table_lineage(
@@ -668,6 +684,7 @@ class DatabricksSource(BaseTabularSource):
         table_ref: TableRef,
         upstream_refs: set[tuple[str, str, str]],
         table_hash_by_key: dict[tuple[str, ...], str],
+        notebook_hash_by_id: dict[str, str] | None = None,
     ) -> None:
         """Turn Unity Catalog's lineage into typed edges.
 
@@ -675,6 +692,9 @@ class DatabricksSource(BaseTabularSource):
         question directly, so nothing here is parsed out of SQL — these edges
         are as trustworthy as lineage gets, and are marked SYSTEM_CATALOG.
 
+        When Unity Catalog saw a notebook run the statement, the edge carries it
+        as ``via`` -- if that notebook is one of this scan's assets.
+
         The upstreams that are *not* part of this scan are the important half.
         They used to be dropped on the floor (``if target in table_hash_by_key``),
         which meant a table fed by a catalog outside the configured scope looked
@@ -686,6 +706,7 @@ class DatabricksSource(BaseTabularSource):
             return
 
         column_mappings = self._column_mappings_for_table(table_ref)
+        notebook_ids = self._lineage_notebook_ids.get(table_ref.table_key, {})
         for upstream in sorted(upstream_refs):
             upstream_hash = table_hash_by_key.get(upstream)
             upstream_ref = (
@@ -693,12 +714,21 @@ class DatabricksSource(BaseTabularSource):
             )
             if upstream_ref is None:
                 continue
+            via_hash = next(
+                (
+                    notebook_hash_by_id[notebook_id]
+                    for notebook_id in sorted(notebook_ids.get(upstream, ()))
+                    if notebook_id in (notebook_hash_by_id or {})
+                ),
+                None,
+            )
             self.add_edge(
                 flow(
                     upstream=upstream_ref,
                     downstream=Ref.asset(downstream_hash),
                     type=FlowType.TRANSFORM,
                     fields=column_mappings.get(upstream, []),
+                    via=Ref.asset(via_hash) if via_hash else None,
                     method=Method.SYSTEM_CATALOG,
                 )
             )
@@ -786,6 +816,7 @@ class DatabricksSource(BaseTabularSource):
                     "get", "/api/2.0/workspace/list", params={"path": path}
                 )
             except Exception as exc:
+                self.note_listing_error()
                 logger.warning("Skipping workspace path %s due to listing error: %s", path, exc)
                 continue
             objects = payload.get("objects")
@@ -865,6 +896,7 @@ class DatabricksSource(BaseTabularSource):
             try:
                 payload = self._request_json("get", "/api/2.0/pipelines", params=params)
             except Exception as exc:
+                self.note_listing_error()
                 logger.warning("Could not list Databricks pipelines: %s", exc)
                 break
             values: list[dict[str, Any]] = []
@@ -935,6 +967,15 @@ class DatabricksSource(BaseTabularSource):
             t.table_key: self.generate_hash_id(t.raw_id) for t in tables
         }
 
+        # Listed before the tables so a lineage edge can name the notebook that
+        # produced it; the notebook assets are still emitted after the tables.
+        notebooks = list(self._iter_notebooks())
+        notebook_hash_by_id = {
+            nb.object_id: self.generate_hash_id(f"notebook_#_{nb.path}")
+            for nb in notebooks
+            if nb.object_id
+        }
+
         include_lineage = self._extraction_options().include_table_lineage
         if include_lineage and tables:
             logger.info("Fetching table lineage for %d table(s)...", len(tables))
@@ -957,7 +998,9 @@ class DatabricksSource(BaseTabularSource):
                         for target in sorted(upstream_refs)
                         if target in table_hash_by_key
                     ]
-                    self._emit_table_lineage(table_ref, upstream_refs, table_hash_by_key)
+                    self._emit_table_lineage(
+                        table_ref, upstream_refs, table_hash_by_key, notebook_hash_by_id
+                    )
                 except Exception as exc:
                     logger.warning(
                         "Could not resolve Databricks lineage for %s: %s", table_label, exc
@@ -974,7 +1017,7 @@ class DatabricksSource(BaseTabularSource):
 
         # Notebooks
         notebook_count = 0
-        for notebook in self._iter_notebooks():
+        for notebook in notebooks:
             if self._aborted:
                 break
             batch.append(self._notebook_to_asset(notebook))
@@ -997,6 +1040,7 @@ class DatabricksSource(BaseTabularSource):
                 batch = []
         if pipeline_count:
             logger.info("Discovered %d pipeline(s)", pipeline_count)
+        self._declare_listing_if_whole()
 
         if batch:
             yield batch

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/src/sources/hive/source.py

@@ -293,7 +293,10 @@ class HiveSource(BaseTabularSource):
             upstreams = [
                 key
                 for key in upstream_tables_from_sql(
-                    definition, dialect="hive", default_database=view.database
+                    definition,
+                    dialect="hive",
+                    default_database=view.database,
+                    two_level=True,
                 )
                 if key != view.table_key and key in scoped
             ]

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/src/sources/mysql/source.py

@@ -322,7 +322,7 @@ class MySQLSource(BaseTabularSource):
                 upstreams = [
                     key
                     for key in upstream_tables_from_sql(
-                        definition, dialect="mysql", default_database=database
+                        definition, dialect="mysql", default_database=database, two_level=True
                     )
                     if key != view_key
                 ]

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/src/sources/neo4j/source.py

@@ -325,6 +325,9 @@ class Neo4jSource(BaseSource):
                 yield batch
                 batch = []
 
+        if not self._aborted and not self._scope_options().node_limit_per_label:
+            self.declare_listing_complete()
+
         if batch:
             logger.info("Emitting final batch of %d asset(s)", len(batch))
             yield batch

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/src/sources/tabular_base.py

@@ -319,9 +319,23 @@ class BaseTabularSource(BaseSource):
             try:
                 tables.extend(self._list_tables_for_database(database))
             except Exception as exc:
+                self.note_listing_error()
                 logger.warning("Skipping database %s due to listing error: %s", database, exc)
         return tables
 
+    def _listing_is_limited(self) -> bool:
+        """Whether a configured cap can have cut the table list short."""
+        scope_options = getattr(self, "_scope_options", None)
+        scope = scope_options() if callable(scope_options) else None
+        return bool(
+            getattr(scope, "table_limit", None) or getattr(scope, "table_limit_per_schema", None)
+        )
+
+    def _declare_listing_if_whole(self) -> None:
+        """Offer this run's table list as the whole scope, when it plausibly is."""
+        if not self._aborted and not self._listing_is_limited():
+            self.declare_listing_complete()
+
     # ── Primary keys ─────────────────────────────────────────────────────
 
     def _get_primary_key_columns(self, table_ref: TableRef) -> list[str]:
@@ -1097,6 +1111,7 @@ class BaseTabularSource(BaseSource):
         table_hash_by_key: dict[tuple[str, ...], str] = {
             t.table_key: self.generate_hash_id(t.raw_id) for t in tables
         }
+        self._declare_listing_if_whole()
         fk_links = self._collect_foreign_key_links(tables)
         self._emit_relationship_edges(tables, table_hash_by_key, fk_links)
 

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/src/utils/sql_lineage.py

@@ -444,6 +444,7 @@ def upstream_tables_from_sql(
     dialect: str | None = None,
     default_database: str | None = None,
     default_schema: str | None = None,
+    two_level: bool = False,
 ) -> list[tuple[str, ...]]:
     """Table keys a statement reads from, for catalogs with no dependency view.
 
@@ -453,6 +454,11 @@ def upstream_tables_from_sql(
     the wrong default schema points at nothing — so callers should prefer the
     catalog wherever it exists and treat these edges as SQL_PARSED.
 
+    ``two_level`` is for engines whose tables are named ``database.table`` (MySQL,
+    Hive). sqlglot files the first part under ``db``, so without it a qualified
+    name came back as ``(default_database, database, table)`` -- a key no asset
+    has, which turned every such view's edges into unresolved ones.
+
     CTE names are excluded: a ``WITH`` alias is not a table, and emitting it
     would create lineage to an object that does not exist.
     """
@@ -481,6 +487,11 @@ def upstream_tables_from_sql(
         name = table.name
         if not name or name.lower() in cte_names:
             continue
+        if two_level:
+            namespace = table.text("db") or default_database
+            if namespace:
+                keys.add((namespace, name))
+            continue
         schema = table.text("db") or default_schema
         database = table.text("catalog") or default_database
         if database and schema:

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/tests/test_databricks_source.py

@@ -415,3 +415,93 @@ async def test_databricks_fetch_content_pages_batches_for_all_strategy(
     assert len(pages) == 12
     assert "item1" in pages[0]
     assert "item12" in pages[11]
+
+
+def test_databricks_column_types_come_from_the_system_catalog(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = DatabricksSource(_pat_recipe())
+    issued: list[str] = []
+
+    class _TypesCursor(_DummyCursor):
+        def execute(self, query: str, _params: Any = None) -> None:
+            issued.append(query)
+            self._rows = [("order_id", "int"), ("line_total", "decimal(21,2)"), ("note", None)]
+
+    class _TypesConnection(_DummyConnection):
+        def cursor(self) -> _TypesCursor:
+            return _TypesCursor()
+
+    monkeypatch.setattr(source, "_get_cached_connection", lambda _db: _TypesConnection())
+    ref = TableRef(database="main", schema="sales", table="order_lines", object_type="TABLE")
+
+    assert source._available_column_types(ref) == {
+        "order_id": "int",
+        "line_total": "decimal(21,2)",
+        "note": "",
+    }
+    assert source._available_columns(ref) == ["order_id", "line_total", "note"]
+    assert "system.information_schema.columns" in issued[0]
+    assert "table_catalog = 'main'" in issued[0]
+
+
+def test_databricks_lineage_edge_names_the_notebook_that_wrote_it(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = DatabricksSource(_pat_recipe())
+    downstream = TableRef(database="main", schema="mart", table="daily", object_type="TABLE")
+    monkeypatch.setattr(
+        source,
+        "_request_json",
+        lambda *_a, **_k: {
+            "upstreams": [
+                {
+                    "tableInfo": {
+                        "catalog_name": "main",
+                        "schema_name": "raw",
+                        "name": "orders",
+                    },
+                    "notebookInfos": [{"notebook_id": 1001}],
+                },
+                {
+                    "tableInfo": {
+                        "catalog_name": "main",
+                        "schema_name": "raw",
+                        "name": "payments",
+                    },
+                },
+            ]
+        },
+    )
+
+    refs = source._lineage_refs_for_table(downstream)
+    table_hashes = {
+        ("main", "raw", "orders"): "h-orders",
+        ("main", "raw", "payments"): "h-payments",
+        downstream.table_key: "h-daily",
+    }
+    source._emit_table_lineage(downstream, refs, table_hashes, {"1001": "h-notebook"})
+
+    edges = {edge.from_hash: edge for edge in source.drain_edges()}
+    assert edges["h-orders"].via_id == "h-notebook"
+    assert edges["h-payments"].via_id is None
+
+
+def test_databricks_unlistable_schema_forfeits_the_complete_declaration(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # A schema whose tables could not be listed must not read as "now empty".
+    source = DatabricksSource(_pat_recipe())
+    monkeypatch.setattr(source, "_list_schemas_for_catalog", lambda _c: ["good", "bad"])
+
+    def _tables(catalog: str, schema: str) -> list[TableRef]:
+        if schema == "bad":
+            raise RuntimeError("permission denied")
+        return [TableRef(database=catalog, schema=schema, table="t", object_type="TABLE")]
+
+    monkeypatch.setattr(source, "_list_tables_for_schema", _tables)
+
+    assert len(source._list_tables_for_database("main")) == 1
+    source._declare_listing_if_whole()
+
+    assert source.listing_complete is False

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/tests/test_hive_source.py

@@ -314,3 +314,26 @@ async def test_hive_fetch_content_pages_batches_for_all_strategy(
     assert len(pages) == 12
     assert "item1" in pages[0]
     assert "item12" in pages[11]
+
+
+def test_hive_view_upstreams_are_database_and_table_keys(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Hive stores view text with database-qualified names; the key must stay
+    # ``(database, table)`` to match an asset, not grow a third part.
+    source = HiveSource(_recipe())
+    monkeypatch.setattr(
+        source,
+        "_view_definition",
+        lambda _ref: "SELECT `o`.`id` FROM `sales`.`orders` `o` JOIN `crm`.`accounts` `a` ON 1=1",
+    )
+    tables = [
+        TableRef(database="reporting", schema=None, table="v_orders", object_type="VIEW"),
+        TableRef(database="sales", schema=None, table="orders", object_type="TABLE"),
+        TableRef(database="crm", schema=None, table="accounts", object_type="TABLE"),
+    ]
+
+    lineage = source._collect_view_lineage(tables)
+
+    assert len(lineage) == 1
+    assert set(lineage[0].upstreams) == {("sales", "orders"), ("crm", "accounts")}

{classifyre_cli-0.7.0 → classifyre_cli-0.7.1}/tests/test_mysql_source.py

@@ -411,3 +411,107 @@ def test_mysql_include_views_false_lists_only_base_tables(
     tables = source._list_tables_for_database("app_db")
 
     assert [(t.table, t.object_type) for t in tables] == [("orders", "TABLE")]
+
+
+class _ViewsCursor:
+    def __init__(self) -> None:
+        self._rows: list[tuple[Any, ...]] = []
+
+    def execute(self, query: str, _params: Any = None) -> None:
+        assert "information_schema.VIEWS" in query
+        self._rows = [
+            (
+                "v_orders_with_manager",
+                "select `app_db`.`o`.`order_id` AS `order_id`,`e`.`full_name` AS `manager` "
+                "from (`app_db`.`orders` `o` left join `hr_db`.`employees` `e` "
+                "on((`e`.`employee_id` = `o`.`account_manager_id`)))",
+            )
+        ]
+
+    def fetchall(self) -> list[tuple[Any, ...]]:
+        return list(self._rows)
+
+    def __enter__(self) -> _ViewsCursor:
+        return self
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        return None
+
+
+class _ViewsConnection:
+    def cursor(self) -> _ViewsCursor:
+        return _ViewsCursor()
+
+
+def test_mysql_view_upstreams_are_database_and_table_keys(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Keys of any other shape name no asset, so every edge of the view would be
+    # left unresolved instead of pointing at the table that was scanned.
+    source = MySQLSource(_recipe())
+    monkeypatch.setattr(source, "_get_cached_connection", lambda _db=None: _ViewsConnection())
+    tables = [
+        TableRef(database="app_db", schema=None, table="orders", object_type="TABLE"),
+        TableRef(database="app_db", schema=None, table="v_orders_with_manager", object_type="VIEW"),
+        TableRef(database="hr_db", schema=None, table="employees", object_type="TABLE"),
+    ]
+
+    lineage = source._collect_view_lineage(tables)
+
+    assert len(lineage) == 1
+    assert lineage[0].view == ("app_db", "v_orders_with_manager")
+    assert set(lineage[0].upstreams) == {("app_db", "orders"), ("hr_db", "employees")}
+
+
+def test_a_failed_database_listing_forfeits_the_complete_declaration(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # A schema that could not be listed says nothing about the tables in it.
+    source = MySQLSource(_recipe())
+    monkeypatch.setattr(source, "_resolve_databases", lambda: ["app_db", "broken_db"])
+
+    def _list(database: str) -> list[TableRef]:
+        if database == "broken_db":
+            raise RuntimeError("access denied")
+        return [TableRef(database=database, schema=None, table="orders")]
+
+    monkeypatch.setattr(source, "_list_tables_for_database", _list)
+
+    tables = source._iter_tables()
+    source._declare_listing_if_whole()
+
+    assert [t.table for t in tables] == ["orders"]
+    assert source.listing_complete is False
+
+
+def test_a_clean_unlimited_listing_is_declared_complete(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source = MySQLSource(_recipe())
+    monkeypatch.setattr(source, "_resolve_databases", lambda: ["app_db"])
+    monkeypatch.setattr(
+        source,
+        "_list_tables_for_database",
+        lambda db: [TableRef(database=db, schema=None, table="orders")],
+    )
+
+    source._iter_tables()
+    source._declare_listing_if_whole()
+
+    assert source.listing_complete is True
+
+
+def test_a_table_limit_means_the_listing_may_be_short() -> None:
+    source = MySQLSource(_recipe(optional={"scope": {"database": "app_db", "table_limit": 5}}))
+
+    source._declare_listing_if_whole()
+
+    assert source.listing_complete is False
+
+
+def test_declared_partial_coverage_overrides_a_complete_listing() -> None:
+    source = MySQLSource(_recipe())
+    source.declare_listing_complete()
+    source.declare_partial_coverage("timed out")
+
+    assert source.listing_complete is False