jerry-thomas 0.3.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

datapipeline/analysis/vector/collector.py

@@ -27,6 +27,7 @@ class VectorStatsCollector:
         expected_feature_ids: Iterable[str] | None = None,
         *,
         match_partition: Literal["base", "full"] = "base",
+        schema_meta: dict[str, dict[str, Any]] | None = None,
         sample_limit: int = 5,
         threshold: float | None = 0.95,
         show_matrix: bool = False,
@@ -48,6 +49,7 @@ class VectorStatsCollector:
             if expected_feature_ids
             else set()
         )
+        self.schema_meta = schema_meta or {}
 
         self.discovered_features: set[str] = set()
         self.discovered_partitions: set[str] = set()
@@ -55,9 +57,14 @@ class VectorStatsCollector:
         self.total_vectors = 0
         self.empty_vectors = 0
 
-        self.present_counts = Counter()
-        self.present_counts_partitions = Counter()
+        self.seen_counts = Counter()
+        self.null_counts_features = Counter()
+        self.seen_counts_partitions = Counter()
         self.null_counts_partitions = Counter()
+        self.cadence_null_counts = Counter()
+        self.cadence_opportunities = Counter()
+        self.cadence_null_counts_partitions = Counter()
+        self.cadence_opportunities_partitions = Counter()
 
         self.missing_samples = defaultdict(list)
         self.missing_partition_samples = defaultdict(list)
@@ -107,6 +114,8 @@ class VectorStatsCollector:
 
         present_normalized: set[str] = set()
         seen_partitions: set[str] = set()
+        feature_seen_present: dict[str, bool] = {}
+        feature_seen_null: dict[str, bool] = {}
         for partition_id in present_partitions:
             normalized = self._normalize(partition_id)
             present_normalized.add(normalized)
@@ -122,12 +131,14 @@ class VectorStatsCollector:
 
             # Capture sub-status for list-valued entries
             sub: list[str] | None = None
+            has_present_element = False
             if isinstance(value, list):
                 sub = []
                 for v in value:
                     if v is None or (isinstance(v, float) and v != v):
                         sub.append("null")
                     else:
+                        has_present_element = True
                         sub.append("present")
                 if sub:
                     self.group_partition_sub[group_key][partition_id] = sub
@@ -135,10 +146,10 @@ class VectorStatsCollector:
                     self.group_feature_sub[group_key].setdefault(
                         normalized, sub)
 
-            is_null = _is_missing_value(value)
+            is_null = (not has_present_element) if isinstance(value, list) else _is_missing_value(value)
             if is_null:
-                status_features[normalized] = "null"
                 status_partitions[partition_id] = "null"
+                feature_seen_null[normalized] = True
                 self.null_counts_partitions[partition_id] += 1
                 if len(self.missing_partition_samples[partition_id]) < self.sample_limit:
                     self.missing_partition_samples[partition_id].append(
@@ -147,14 +158,30 @@ class VectorStatsCollector:
                 if len(self.missing_samples[normalized]) < self.sample_limit:
                     self.missing_samples[normalized].append(
                         (group_key, "null"))
+            else:
+                feature_seen_present[normalized] = True
+
+            # Cadence-aware null accounting (per schema metadata)
+            meta = self.schema_meta.get(normalized) or self.schema_meta.get(partition_id)
+            expected_len = self._cadence_expected_length(meta) if meta else None
+            if expected_len is not None:
+                self._update_cadence(normalized, expected_len, value, partitions=False)
+                self._update_cadence(partition_id, expected_len, value, partitions=True)
 
         for normalized in present_normalized:
-            if status_features.get(normalized) == "present":
-                self.present_counts[normalized] += 1
+            if feature_seen_present.get(normalized):
+                status_features[normalized] = "present"
+                # Drop stale null samples when the feature is ultimately present
+                self.missing_samples.pop(normalized, None)
+            elif feature_seen_null.get(normalized):
+                status_features[normalized] = "null"
+                self.null_counts_features[normalized] += 1
+            # Count availability (seen) regardless of value
+            self.seen_counts[normalized] += 1
 
         for partition_id in seen_partitions:
-            if status_partitions.get(partition_id) == "present":
-                self.present_counts_partitions[partition_id] += 1
+            # Availability regardless of value
+            self.seen_counts_partitions[partition_id] += 1
 
         tracked_features = (
             self.expected_features if self.expected_features else self.discovered_features
@@ -186,20 +213,16 @@ class VectorStatsCollector:
         self, identifier: str, *, partitions: bool = False
     ) -> tuple[int, int, int]:
         present = (
-            self.present_counts_partitions[identifier]
+            self.seen_counts_partitions[identifier]
             if partitions
-            else self.present_counts[identifier]
+            else self.seen_counts[identifier]
         )
         opportunities = self.total_vectors
         missing = max(opportunities - present, 0)
         return present, missing, opportunities
 
     def _feature_null_count(self, feature_id: str) -> int:
-        total = 0
-        for partition_id, count in self.null_counts_partitions.items():
-            if self._normalize(partition_id) == feature_id:
-                total += count
-        return total
+        return self.null_counts_features.get(feature_id, 0)
 
     @staticmethod
     def _format_group_key(group_key: Hashable) -> str:
@@ -230,6 +253,86 @@ class VectorStatsCollector:
     def _partition_suffix(partition_id: str) -> str:
         return partition_id.split("__", 1)[1] if "__" in partition_id else partition_id
 
+    @staticmethod
+    def _partition_values(partition_id: str) -> list[str]:
+        """Return partition values without base id or field names."""
+        suffix = partition_id.split("__", 1)[1] if "__" in partition_id else partition_id
+        if not suffix:
+            return []
+
+        def _components(raw: str) -> list[str]:
+            if raw.startswith("@"):
+                parts = raw.split("_@")
+                return [parts[0]] + [f"@{rest}" for rest in parts[1:]]
+            return [raw]
+
+        values: list[str] = []
+        for component in _components(suffix):
+            field_value = component.lstrip("@")
+            _, _, value = field_value.partition(":")
+            candidate = value or field_value
+            # If no explicit value delimiter, drop leading field name-ish prefixes
+            if not value and "_" in candidate:
+                candidate = candidate.rsplit("_", 1)[-1]
+            values.append(candidate)
+        return values
+
+    @classmethod
+    def _partition_value(cls, partition_id: str) -> str:
+        values = cls._partition_values(partition_id)
+        if not values:
+            return ""
+        return values[0] if len(values) == 1 else "_".join(values)
+
+    @staticmethod
+    def _expected_lengths(meta: dict[str, Any]) -> list[int]:
+        cadence = meta.get("cadence")
+        if isinstance(cadence, dict):
+            target = cadence.get("target")
+            if isinstance(target, (int, float)) and target > 0:
+                return [int(target)]
+        modes = meta.get("list_length", {}).get("modes")
+        if isinstance(modes, (list, tuple)) and modes:
+            ints = [int(m) for m in modes if isinstance(m, (int, float))]
+            if ints:
+                return sorted(ints)
+        expected = meta.get("expected_length")
+        if isinstance(expected, (int, float)):
+            return [int(expected)]
+        max_len = meta.get("list_length", {}).get("max")
+        if isinstance(max_len, (int, float)) and max_len > 0:
+            return [int(max_len)]
+        return []
+
+    @staticmethod
+    def _cadence_expected_length(meta: dict[str, Any]) -> int | None:
+        lengths = VectorStatsCollector._expected_lengths(meta)
+        return max(lengths) if lengths else None
+
+    def _update_cadence(
+        self, identifier: str, expected_len: int | None, value: Any, *, partitions: bool
+    ) -> None:
+        if expected_len is None:
+            return
+        counter_nulls = (
+            self.cadence_null_counts_partitions if partitions else self.cadence_null_counts
+        )
+        counter_opps = (
+            self.cadence_opportunities_partitions
+            if partitions
+            else self.cadence_opportunities
+        )
+
+        present = 0
+        if isinstance(value, list):
+            trimmed = value[:expected_len]
+            present = sum(0 if _is_missing_value(v) else 1 for v in trimmed)
+        else:
+            present = 0 if _is_missing_value(value) else 1
+        missing = max(expected_len - present, 0)
+        counter_opps[identifier] += expected_len
+        counter_nulls[identifier] += missing
+
     def _render_matrix(
         self,
         *,
@@ -246,10 +349,10 @@ class VectorStatsCollector:
             column_width=column_width,
         )
 
-    def print_report(self) -> dict[str, Any]:
+    def print_report(self, *, sort_key: str = "missing") -> dict[str, Any]:
         from .report import print_report as _print_report
 
-        return _print_report(self)
+        return _print_report(self, sort_key=sort_key)
 
     def _export_matrix_data(self) -> None:
         from .matrix import export_matrix_data

datapipeline/analysis/vector/matrix.py

@@ -81,11 +81,11 @@ def export_matrix_data(collector: VectorStatsCollector) -> None:
             _write_matrix_html(collector, path)
         else:
             _write_matrix_csv(collector, path)
-        logger.info("\n[write] Saved availability matrix to %s", path)
+        message = f"[write] Saved availability matrix to {path}"
+        logger.info("\n%s", message)
     except OSError as exc:
-        logger.warning(
-            "\n[warn] Failed to write availability matrix to %s: %s", path, exc
-        )
+        warning = f"[warn] Failed to write availability matrix to {path}: {exc}"
+        logger.warning("\n%s", warning)
 
 
 def _write_matrix_csv(collector: VectorStatsCollector, path: Path) -> None:
@@ -341,10 +341,11 @@ def _write_matrix_html(collector: VectorStatsCollector, path: Path) -> None:
         .heatmap th,
         .heatmap td {
             border: 1px solid #d0d0d0;
-            padding: 4px 6px;
+            padding: 0 5px;
             text-align: center;
             font-size: 13px;
             line-height: 1.2;
+            vertical-align: middle;
         }
         .heatmap thead th {
             position: sticky;
@@ -369,9 +370,33 @@ def _write_matrix_html(collector: VectorStatsCollector, path: Path) -> None:
         .status-null { background: #f1c40f; color: #000; font-weight: bold; }
         .status-absent { background: #e74c3c; color: #fff; font-weight: bold; }
         .status-missing { background: #bdc3c7; color: #000; font-weight: bold; }
-        .sub { display: flex; gap: 1px; height: 12px; }
-        .sub span { flex: 1; display: block; }
-        .sub span::after { content: ""; display: block; width: 100%; height: 100%; }
+        .sub {
+            display: flex;
+            gap: 5px;
+            height: calc(100% - 2px);
+            min-height: 24px;
+            padding: 0 2px;
+            margin: 1px 0;
+            align-items: stretch;
+            justify-content: center;
+        }
+        .sub span {
+            flex: 1;
+            display: block;
+            position: relative;
+            border-radius: 4px;
+            overflow: hidden;
+            border: 1px solid rgba(0,0,0,0.15);
+            background: #fff;
+            min-width: 12px;
+        }
+        .sub span::after {
+            content: "";
+            position: absolute;
+            inset: 0;
+            display: block;
+            border-radius: 4px;
+        }
         .sub .status-present::after { background: #2ecc71; }
         .sub .status-null::after { background: #f1c40f; }
         .sub .status-absent::after { background: #e74c3c; }

datapipeline/analysis/vector/report.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
-from typing import Any
+from typing import Any, Literal, TYPE_CHECKING
 import logging
 
 from .matrix import export_matrix_data, render_matrix
-from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from .collector import VectorStatsCollector
@@ -12,7 +11,11 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
+def print_report(
+    collector: VectorStatsCollector,
+    *,
+    sort_key: Literal["missing", "nulls"] = "missing",
+) -> dict[str, Any]:
     tracked_features = (
         collector.expected_features
         if collector.expected_features
@@ -62,15 +65,25 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
         return summary
 
     feature_stats = []
-    logger.info("\n-> Feature coverage (sorted by missing count):")
+    sort_label = "null" if sort_key == "nulls" else "missing"
+    logger.info("\n-> Feature coverage (sorted by %s count):", sort_label)
+    if sort_key == "nulls":
+        def _feature_sort(fid):
+            return collector._feature_null_count(fid)
+    else:
+        def _feature_sort(fid):
+            return collector._coverage(fid)[1]
+
     for feature_id in sorted(
         tracked_features,
-        key=lambda fid: collector._coverage(fid)[1],
+        key=_feature_sort,
         reverse=True,
     ):
         present, missing, opportunities = collector._coverage(feature_id)
         coverage = present / opportunities if opportunities else 0.0
         nulls = collector._feature_null_count(feature_id)
+        cadence_nulls = collector.cadence_null_counts.get(feature_id, 0)
+        cadence_opps = collector.cadence_opportunities.get(feature_id, 0)
         raw_samples = collector.missing_samples.get(feature_id, [])
         sample_note = collector._format_samples(raw_samples)
         samples = [
@@ -82,7 +95,7 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
         ]
         line = (
             f"  - {feature_id}: present {present}/{opportunities}"
-            f" ({coverage:.1%}) | missing {missing} | null {nulls}"
+            f" ({coverage:.1%}) | absent {missing} | null {nulls}"
         )
         if sample_note:
             line += f"; samples: {sample_note}"
@@ -93,6 +106,11 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
                 "present": present,
                 "missing": missing,
                 "nulls": nulls,
+                "cadence_nulls": cadence_nulls,
+                "cadence_opportunities": cadence_opps,
+                "cadence_null_fraction": (
+                    cadence_nulls / cadence_opps if cadence_opps else None
+                ),
                 "coverage": coverage,
                 "opportunities": opportunities,
                 "samples": samples,
@@ -109,6 +127,12 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
             )
             coverage = present / opportunities if opportunities else 0.0
             nulls = collector.null_counts_partitions.get(partition_id, 0)
+            cadence_nulls = collector.cadence_null_counts_partitions.get(
+                partition_id, 0
+            )
+            cadence_opps = collector.cadence_opportunities_partitions.get(
+                partition_id, 0
+            )
             raw_samples = collector.missing_partition_samples.get(
                 partition_id, [])
             partition_stats.append(
@@ -118,6 +142,11 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
                     "present": present,
                     "missing": missing,
                     "nulls": nulls,
+                    "cadence_nulls": cadence_nulls,
+                    "cadence_opportunities": cadence_opps,
+                    "cadence_null_fraction": (
+                        cadence_nulls / cadence_opps if cadence_opps else None
+                    ),
                     "coverage": coverage,
                     "opportunities": opportunities,
                     "samples": [
@@ -130,13 +159,16 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
                 }
             )
 
-        logger.info("\n-> Partition details (top by missing count):")
+        sort_label_partitions = "null" if sort_key == "nulls" else "absent"
+        logger.info("\n-> Partition details (top by %s count):", sort_label_partitions)
+        def _partition_sort(stats):
+            return stats["nulls"] if sort_key == "nulls" else stats["missing"]
         for stats in sorted(
-            partition_stats, key=lambda s: s["missing"], reverse=True
+            partition_stats, key=_partition_sort, reverse=True
         )[:20]:
             line = (
                 f"  - {stats['id']} (base: {stats['base']}): present {stats['present']}/{stats['opportunities']}"
-                f" ({stats['coverage']:.1%}) | missing {stats['missing']} | null/invalid {stats['nulls']}"
+                f" ({stats['coverage']:.1%}) | absent {stats['missing']} | null/invalid {stats['nulls']}"
             )
             logger.info(line)
 
@@ -148,6 +180,10 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
     above_partitions: list[str] = []
     below_suffixes: list[str] = []
     above_suffixes: list[str] = []
+    below_partition_values: list[str] = []
+    above_partition_values: list[str] = []
+    below_partitions_cadence: list[str] = []
+    above_partitions_cadence: list[str] = []
 
     if collector.threshold is not None:
         thr = collector.threshold
@@ -157,17 +193,6 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
         above_features = [
             stats["id"] for stats in feature_stats if stats["coverage"] >= thr
         ]
-        logger.warning(
-            "\n[low] Features below %.0f%% coverage:\n  below_features = %s",
-            thr * 100,
-            below_features,
-        )
-        logger.info(
-            "[high] Features at/above %.0f%% coverage:\n  keep_features = %s",
-            thr * 100,
-            above_features,
-        )
-
         if partition_stats:
             below_partitions = [
                 stats["id"] for stats in partition_stats if stats["coverage"] < thr
@@ -185,18 +210,26 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
             ]
             if not above_partitions:
                 above_suffixes = []
-            logger.warning(
-                "\n[low] Partitions below %.0f%% coverage:\n  below_partitions = %s",
-                thr * 100,
-                below_partitions,
-            )
-            logger.warning("  below_suffixes = %s", below_suffixes)
-            logger.info(
-                "[high] Partitions at/above %.0f%% coverage:\n  keep_partitions = %s",
-                thr * 100,
-                above_partitions,
-            )
-            logger.info("  keep_suffixes = %s", above_suffixes)
+            below_partition_values = [
+                v
+                for pid in below_partitions
+                if "__" in pid and (v := collector._partition_value(pid))
+            ]
+            above_partition_values = [
+                v
+                for pid in above_partitions
+                if "__" in pid and (v := collector._partition_value(pid))
+            ]
+            below_partitions_cadence = [
+                stats["id"]
+                for stats in partition_stats
+                if (stats.get("cadence_null_fraction") or 0) > (1 - thr)
+            ]
+            above_partitions_cadence = [
+                stats["id"]
+                for stats in partition_stats
+                if (stats.get("cadence_null_fraction") or 0) <= (1 - thr)
+            ]
 
     summary.update(
         {
@@ -216,6 +249,21 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
                 if partition_stats
                 else []
             ),
+            "below_partition_values": below_partition_values,
+            "keep_partition_values": above_partition_values
+            or (
+                [
+                    collector._partition_value(stats["id"])
+                    for stats in partition_stats
+                    if "__" in stats["id"]
+                    and collector._partition_value(stats["id"])
+                ]
+                if partition_stats
+                else []
+            ),
+            "below_partitions_cadence": below_partitions_cadence,
+            "keep_partitions_cadence": above_partitions_cadence
+            or [stats["id"] for stats in partition_stats],
         }
     )
 
@@ -310,6 +358,88 @@ def print_report(collector: VectorStatsCollector) -> dict[str, Any]:
     if collector.matrix_output:
         export_matrix_data(collector)
 
+    # Record-level (cadence) gaps for list features/partitions
+    partition_cadence = [
+        stats
+        for stats in partition_stats
+        if stats.get("cadence_opportunities")
+    ]
+    if partition_cadence:
+        logger.info("\n-> Record-level gaps (expected cadence; null/invalid elements):")
+        total_missing = sum(s.get("cadence_nulls", 0) or 0 for s in partition_cadence)
+        total_opps = sum(s.get("cadence_opportunities", 0) or 0 for s in partition_cadence)
+        if total_opps:
+            logger.info(
+                "  Total null/invalid elements: %d/%d (%.1f%%)",
+                total_missing,
+                total_opps,
+                (total_missing / total_opps) * 100,
+            )
+        logger.info("  Top partitions by null/invalid elements:")
+        for stats in sorted(
+            partition_cadence,
+            key=lambda s: (s.get("cadence_nulls") or 0),
+            reverse=True,
+        )[:20]:
+            missing_elems = stats.get("cadence_nulls") or 0
+            opps = stats.get("cadence_opportunities") or 0
+            frac = (missing_elems / opps) if opps else 0
+            logger.info(
+                "  - %s (base: %s): vectors present %d/%d | absent %d | cadence null/invalid %d/%d elements (%.1f%%)",
+                stats["id"],
+                stats.get("base"),
+                stats.get("present", 0),
+                stats.get("opportunities", 0),
+                stats.get("missing", 0),
+                missing_elems,
+                opps,
+                frac * 100,
+            )
+
+    if collector.threshold is not None:
+        thr = collector.threshold
+        logger.warning(
+            "\n[low] Features below %.0f%% coverage:\n  below_features = %s",
+            thr * 100,
+            below_features,
+        )
+        logger.info(
+            "[high] Features at/above %.0f%% coverage:\n  keep_features = %s",
+            thr * 100,
+            above_features,
+        )
+        if partition_stats:
+            logger.warning(
+                "\n[low] Partitions below %.0f%% coverage:\n  below_partitions = %s",
+                thr * 100,
+                below_partitions,
+            )
+            logger.warning("  below_suffixes = %s", below_suffixes)
+            if below_partition_values:
+                logger.warning("  below_partition_values = %s",
+                               below_partition_values)
+            logger.info(
+                "[high] Partitions at/above %.0f%% coverage:\n  keep_partitions = %s",
+                thr * 100,
+                above_partitions,
+            )
+            logger.info("  keep_suffixes = %s", above_suffixes)
+            if above_partition_values:
+                logger.info(
+                    "  keep_partition_values = %s", above_partition_values)
+            if below_partitions_cadence:
+                logger.warning(
+                    "[low] Partitions below %.0f%% cadence fill:\n  below_partitions_cadence = %s",
+                    thr * 100,
+                    below_partitions_cadence,
+                )
+            if above_partitions_cadence:
+                logger.info(
+                    "[high] Partitions at/above %.0f%% cadence fill:\n  keep_partitions_cadence = %s",
+                    thr * 100,
+                    above_partitions_cadence,
+                )
+
     return summary
 
 

datapipeline/build/tasks/__init__.py

@@ -0,0 +1,11 @@
+from .config import compute_config_hash
+from .schema import materialize_vector_schema
+from .metadata import materialize_metadata
+from .scaler import materialize_scaler_statistics
+
+__all__ = [
+    "compute_config_hash",
+    "materialize_vector_schema",
+    "materialize_metadata",
+    "materialize_scaler_statistics",
+]

datapipeline/build/tasks/config.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Iterable
+
+from datapipeline.services.project_paths import read_project
+
+
+def _resolve_relative(project_yaml: Path, value: str) -> Path:
+    path = Path(value)
+    return path if path.is_absolute() else (project_yaml.parent / path)
+
+
+def _normalized_label(path: Path, base_dir: Path) -> str:
+    try:
+        return str(path.resolve().relative_to(base_dir))
+    except ValueError:
+        return str(path.resolve())
+
+
+def _hash_file(hasher, path: Path, base_dir: Path) -> None:
+    hasher.update(_normalized_label(path, base_dir).encode("utf-8"))
+    hasher.update(b"\0")
+    hasher.update(path.read_bytes())
+    hasher.update(b"\0")
+
+
+def _yaml_files(directory: Path) -> Iterable[Path]:
+    if not directory.exists():
+        return []
+    return sorted(p for p in directory.rglob("*.y*ml") if p.is_file())
+
+
+def compute_config_hash(project_yaml: Path, tasks_path: Path) -> str:
+    """Compute a deterministic hash across relevant config inputs."""
+
+    hasher = hashlib.sha256()
+    base_dir = project_yaml.parent.resolve()
+    cfg = read_project(project_yaml)
+
+    required = [
+        project_yaml.resolve(),
+        _resolve_relative(project_yaml, cfg.paths.dataset).resolve(),
+        _resolve_relative(project_yaml, cfg.paths.postprocess).resolve(),
+    ]
+
+    for path in required:
+        if not path.exists():
+            raise FileNotFoundError(f"Expected config file missing: {path}")
+        _hash_file(hasher, path, base_dir)
+
+    if not tasks_path.is_dir():
+        raise TypeError(
+            f"project.paths.tasks must point to a directory, got: {tasks_path}"
+        )
+    hasher.update(
+        f"[dir]{_normalized_label(tasks_path, base_dir)}".encode("utf-8")
+    )
+    for p in _yaml_files(tasks_path):
+        _hash_file(hasher, p, base_dir)
+
+    for dir_value in (cfg.paths.sources, cfg.paths.streams):
+        directory = _resolve_relative(project_yaml, dir_value)
+        hasher.update(
+            f"[dir]{_normalized_label(directory, base_dir)}".encode("utf-8")
+        )
+        if not directory.exists():
+            hasher.update(b"[missing]")
+            continue
+        for path in _yaml_files(directory):
+            _hash_file(hasher, path, base_dir)
+
+    return hasher.hexdigest()