checkup-dbt 0.2.0__tar.gz

checkup_dbt-0.2.0/.gitignore

@@ -0,0 +1,15 @@
+.env
+dist
+site/
+
+.DS_Store
+__pycache__
+
+# Testing
+.coverage
+coverage.xml
+htmlcov/
+.pytest_cache/
+
+# Virtual environments
+.venv/

checkup_dbt-0.2.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: checkup-dbt
+Version: 0.2.0
+Summary: dbt metrics for checkup
+Requires-Python: >=3.12
+Requires-Dist: checkup
+Requires-Dist: dbt-core>=1.9

checkup_dbt-0.2.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "checkup-dbt"
+version = "0.2.0"
+description = "dbt metrics for checkup"
+requires-python = ">=3.12"
+dependencies = [
+    "checkup",
+    "dbt-core>=1.9",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "dbt-duckdb>=1.9",
+]
+
+[tool.uv.sources]
+checkup = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/checkup_dbt"]

checkup_dbt-0.2.0/src/checkup_dbt/__init__.py

@@ -0,0 +1,57 @@
+"""dbt metrics for checkup."""
+
+from checkup_dbt.metrics import (
+    DbtColumnsMetric,
+    DbtColumnsWithDescriptionMetric,
+    DbtColumnsWithoutDescriptionMetric,
+    DbtColumnTestCoverageMetric,
+    DbtColumnTestsMetric,
+    DbtDataTestsMetric,
+    DbtFlaggedPackagesMetric,
+    DbtMetric,
+    DbtModelsMetric,
+    DbtModelsNotAdheringToNamingConventionMetric,
+    DbtModelsWithDescriptionMetric,
+    DbtModelsWithoutDescriptionMetric,
+    DbtOutputColumnsWithoutDataTypeMetric,
+    DbtOutputModelsMetric,
+    DbtOutputModelsWithDescriptionMetric,
+    DbtOutputModelsWithoutContractsMetric,
+    DbtOutputModelsWithoutDescriptionMetric,
+    DbtProfileHostMetric,
+    DbtSupportedVersionMetric,
+    DbtTestedColumnsMetric,
+    DbtTestsMetric,
+    DbtUnitTestsMetric,
+    DbtVersionMetric,
+    NamingConventionChecker,
+)
+from checkup_dbt.provider import DbtManifestProvider
+
+__all__ = [
+    "DbtManifestProvider",
+    "DbtMetric",
+    "NamingConventionChecker",
+    "DbtModelsMetric",
+    "DbtColumnsMetric",
+    "DbtTestsMetric",
+    "DbtModelsWithDescriptionMetric",
+    "DbtModelsWithoutDescriptionMetric",
+    "DbtColumnsWithDescriptionMetric",
+    "DbtColumnsWithoutDescriptionMetric",
+    "DbtUnitTestsMetric",
+    "DbtDataTestsMetric",
+    "DbtColumnTestsMetric",
+    "DbtTestedColumnsMetric",
+    "DbtColumnTestCoverageMetric",
+    "DbtOutputModelsMetric",
+    "DbtOutputModelsWithDescriptionMetric",
+    "DbtOutputModelsWithoutDescriptionMetric",
+    "DbtOutputModelsWithoutContractsMetric",
+    "DbtOutputColumnsWithoutDataTypeMetric",
+    "DbtFlaggedPackagesMetric",
+    "DbtProfileHostMetric",
+    "DbtModelsNotAdheringToNamingConventionMetric",
+    "DbtSupportedVersionMetric",
+    "DbtVersionMetric",
+]

checkup_dbt-0.2.0/src/checkup_dbt/manifest_query.py

@@ -0,0 +1,199 @@
+"""ManifestQuery utility for querying dbt manifest data.
+
+Provides a fluent interface for filtering and counting nodes in dbt manifests.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import Any
+
+from dbt.artifacts.resources.types import NodeType
+from dbt.contracts.graph.manifest import Manifest
+
+
+class ManifestQuery:
+    """Fluent query builder for dbt manifest nodes.
+
+    Example:
+        count = (
+            ManifestQuery(manifest)
+            .filter_by_type(NodeType.Model)
+            .filter(lambda n: n.description != "")
+            .count()
+        )
+    """
+
+    def __init__(self, manifest: Manifest):
+        """Initialize with a dbt manifest.
+
+        Args:
+            manifest: The dbt Manifest object to query
+        """
+        self._manifest = manifest
+        self._nodes: Iterable[Any] | None = None
+        self._filters: list[Callable[[Any], bool]] = []
+
+    def _get_nodes(self) -> Iterable[Any]:
+        """Get the current node set."""
+        if self._nodes is not None:
+            return self._nodes
+        return self._manifest.nodes.values()
+
+    def filter_by_type(self, resource_type: NodeType) -> ManifestQuery:
+        """Filter nodes by resource type.
+
+        Args:
+            resource_type: The NodeType to filter by (e.g., NodeType.Model)
+
+        Returns:
+            Self for chaining
+        """
+        self._filters.append(lambda n: n.resource_type == resource_type)
+        return self
+
+    def filter(self, predicate: Callable[[Any], bool]) -> ManifestQuery:
+        """Filter nodes by a custom predicate.
+
+        Args:
+            predicate: Function that returns True for nodes to include
+
+        Returns:
+            Self for chaining
+        """
+        self._filters.append(predicate)
+        return self
+
+    def _apply_filters(self) -> list[Any]:
+        """Apply all filters and return matching nodes."""
+        nodes = list(self._get_nodes())
+        for f in self._filters:
+            nodes = [n for n in nodes if f(n)]
+        return nodes
+
+    def count(self) -> int:
+        """Count nodes matching all filters.
+
+        Returns:
+            Number of matching nodes
+        """
+        return len(self._apply_filters())
+
+    def list(self) -> list[Any]:
+        """Get list of nodes matching all filters.
+
+        Returns:
+            List of matching nodes
+        """
+        return self._apply_filters()
+
+    def names(self) -> list[str]:
+        """Get names of nodes matching all filters.
+
+        Returns:
+            List of node names, sorted alphabetically
+        """
+        return sorted(n.name for n in self._apply_filters())
+
+    def count_columns(
+        self, column_predicate: Callable[[Any, str, Any], bool] | None = None
+    ) -> int:
+        """Count columns across matching nodes.
+
+        Args:
+            column_predicate: Optional function(node, col_name, col) -> bool
+
+        Returns:
+            Total column count across matching nodes
+        """
+        nodes = self._apply_filters()
+        count = 0
+        for node in nodes:
+            for col_name, col in node.columns.items():
+                if column_predicate is None or column_predicate(node, col_name, col):
+                    count += 1
+        return count
+
+    def columns(
+        self, column_predicate: Callable[[Any, str, Any], bool] | None = None
+    ) -> list[tuple[Any, str, Any]]:
+        """Get columns across matching nodes.
+
+        Args:
+            column_predicate: Optional function(node, col_name, col) -> bool
+
+        Returns:
+            List of (node, column_name, column) tuples
+        """
+        nodes = self._apply_filters()
+        result = []
+        for node in nodes:
+            for col_name, col in node.columns.items():
+                if column_predicate is None or column_predicate(node, col_name, col):
+                    result.append((node, col_name, col))
+        return result
+
+    def column_names(
+        self, column_predicate: Callable[[Any, str, Any], bool] | None = None
+    ) -> list[str]:
+        """Get column names in 'model.column' format.
+
+        Args:
+            column_predicate: Optional function(node, col_name, col) -> bool
+
+        Returns:
+            List of 'model.column' strings, sorted
+        """
+        columns = self.columns(column_predicate)
+        return sorted(f"{node.name}.{col_name}" for node, col_name, _ in columns)
+
+
+# Common predicates for reuse
+def has_description(node: Any) -> bool:
+    """Check if node has a non-empty description."""
+    return node.description != ""
+
+
+def without_description(node: Any) -> bool:
+    """Check if node is missing a description."""
+    return node.description == ""
+
+
+def is_output_model(node: Any) -> bool:
+    """Check if node is an output model (non-internal schema)."""
+    return node.resource_type == NodeType.Model and not node.schema.endswith("__int")
+
+
+def has_enforced_contract(node: Any) -> bool:
+    """Check if node has an enforced contract."""
+    return node.contract.enforced
+
+
+def is_generic_test(node: Any) -> bool:
+    """Check if node is a generic (data) test."""
+    return getattr(node, "test_node_type", None) == "generic"
+
+
+def is_singular_test(node: Any) -> bool:
+    """Check if node is a singular (unit) test."""
+    return getattr(node, "test_node_type", None) == "singular"
+
+
+def is_column_test(node: Any) -> bool:
+    """Check if test targets a specific column."""
+    return hasattr(node, "column_name") and node.column_name is not None
+
+
+def column_has_description(_node: Any, _col_name: str, col: Any) -> bool:
+    """Check if column has a non-empty description."""
+    return col.description != ""
+
+
+def column_without_description(_node: Any, _col_name: str, col: Any) -> bool:
+    """Check if column is missing a description."""
+    return col.description == ""
+
+
+def column_missing_data_type(_node: Any, _col_name: str, col: Any) -> bool:
+    """Check if column is missing a data type."""
+    return col.data_type is None

checkup_dbt-0.2.0/src/checkup_dbt/metrics/__init__.py

@@ -0,0 +1,58 @@
+from checkup_dbt.metrics.base import DbtMetric, NamingConventionChecker
+from checkup_dbt.metrics.core import (
+    DbtColumnsMetric,
+    DbtColumnsWithDescriptionMetric,
+    DbtColumnsWithoutDescriptionMetric,
+    DbtModelsMetric,
+    DbtModelsWithDescriptionMetric,
+    DbtModelsWithoutDescriptionMetric,
+    DbtTestsMetric,
+)
+from checkup_dbt.metrics.output import (
+    DbtOutputColumnsWithoutDataTypeMetric,
+    DbtOutputModelsMetric,
+    DbtOutputModelsWithDescriptionMetric,
+    DbtOutputModelsWithoutContractsMetric,
+    DbtOutputModelsWithoutDescriptionMetric,
+)
+from checkup_dbt.metrics.quality import (
+    DbtFlaggedPackagesMetric,
+    DbtModelsNotAdheringToNamingConventionMetric,
+    DbtProfileHostMetric,
+    DbtSupportedVersionMetric,
+    DbtVersionMetric,
+)
+from checkup_dbt.metrics.test import (
+    DbtColumnTestCoverageMetric,
+    DbtColumnTestsMetric,
+    DbtDataTestsMetric,
+    DbtTestedColumnsMetric,
+    DbtUnitTestsMetric,
+)
+
+__all__ = [
+    "DbtMetric",
+    "NamingConventionChecker",
+    "DbtModelsMetric",
+    "DbtColumnsMetric",
+    "DbtTestsMetric",
+    "DbtModelsWithDescriptionMetric",
+    "DbtModelsWithoutDescriptionMetric",
+    "DbtColumnsWithDescriptionMetric",
+    "DbtColumnsWithoutDescriptionMetric",
+    "DbtUnitTestsMetric",
+    "DbtDataTestsMetric",
+    "DbtColumnTestsMetric",
+    "DbtTestedColumnsMetric",
+    "DbtColumnTestCoverageMetric",
+    "DbtOutputModelsMetric",
+    "DbtOutputModelsWithDescriptionMetric",
+    "DbtOutputModelsWithoutDescriptionMetric",
+    "DbtOutputModelsWithoutContractsMetric",
+    "DbtOutputColumnsWithoutDataTypeMetric",
+    "DbtFlaggedPackagesMetric",
+    "DbtModelsNotAdheringToNamingConventionMetric",
+    "DbtProfileHostMetric",
+    "DbtSupportedVersionMetric",
+    "DbtVersionMetric",
+]

checkup_dbt-0.2.0/src/checkup_dbt/metrics/base.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from enum import Enum, auto
+from pathlib import Path
+from typing import Any, ClassVar
+
+from dbt.artifacts.resources.types import NodeType
+from dbt.contracts.graph.manifest import Manifest
+
+from checkup.metric import Metric
+from checkup.provider import Provider
+from checkup.types import Context
+from checkup_dbt.manifest_query import ManifestQuery
+from checkup_dbt.provider import DbtManifestProvider
+
+NamingConventionChecker = Callable[[Context, Any], bool]
+
+logger = logging.getLogger(__name__)
+
+
+class CountTarget(Enum):
+    """What to count in a diagnostic metric."""
+
+    NODES = auto()
+    COLUMNS = auto()
+
+
+class DbtMetric(Metric):
+    """Base class for dbt metrics."""
+
+    @classmethod
+    def providers(cls) -> list[type[Provider]]:
+        return [DbtManifestProvider]
+
+    def get_manifest(self, context: Context) -> Manifest:
+        """Get the manifest from context.
+
+        Args:
+            context: The context dict
+
+        Returns:
+            The dbt Manifest object
+        """
+        return context[DbtManifestProvider.name]["manifest"]
+
+    def get_project_dir(self, context: Context) -> Path:
+        """Get the dbt project directory from context.
+
+        Args:
+            context: The context dict
+
+        Returns:
+            Path to the dbt project directory
+        """
+        return context[DbtManifestProvider.name]["project_dir"]
+
+    def query(self, context: Context) -> ManifestQuery:
+        """Create a ManifestQuery for the context's manifest.
+
+        Args:
+            context: The context dict
+
+        Returns:
+            ManifestQuery instance for fluent querying
+        """
+        return ManifestQuery(self.get_manifest(context))
+
+
+class DbtCountMetric(DbtMetric):
+    """Base class for metrics that count nodes or columns.
+
+    Subclasses should define:
+    - name, description, unit (ClassVars)
+    - resource_type: The NodeType to filter by
+    - count_target: What to count (NODES or COLUMNS)
+    - predicate (optional): Filter function
+      - For NODES: Callable[[node], bool]
+      - For COLUMNS: Callable[[node, col_name, col], bool]
+    - log_message: Template for log message (uses {value})
+    """
+
+    resource_type: ClassVar[NodeType] = NodeType.Model
+    count_target: ClassVar[CountTarget] = CountTarget.NODES
+    predicate: ClassVar[Callable[..., bool] | None] = None
+    log_message: ClassVar[str] = "Found {value} items"
+
+    def calculate(self, context: Context, metrics: dict) -> None:
+        cls = type(self)
+        query = self.query(context).filter_by_type(cls.resource_type)
+
+        if cls.count_target == CountTarget.COLUMNS:
+            self.value = query.count_columns(cls.predicate)
+        else:
+            if cls.predicate:
+                query = query.filter(cls.predicate)
+            self.value = query.count()
+
+        logger.info(cls.log_message.format(value=self.value))
+
+
+class DbtDiagnosticMetric(DbtMetric):
+    """Base class for metrics that count and list items with diagnostics.
+
+    Produces both a count and a diagnostic listing the items.
+
+    Subclasses should define:
+    - name, description, unit (ClassVars)
+    - resource_type: The NodeType to filter by
+    - count_target: What to count (NODES or COLUMNS)
+    - predicate (optional): Filter function
+      - For NODES: Callable[[node], bool]
+      - For COLUMNS: Callable[[node, col_name, col], bool]
+    - diagnostic_prefix: Prefix for diagnostic message
+    - log_message: Template for log message (uses {value})
+    """
+
+    resource_type: ClassVar[NodeType] = NodeType.Model
+    count_target: ClassVar[CountTarget] = CountTarget.NODES
+    predicate: ClassVar[Callable[..., bool] | None] = None
+    diagnostic_prefix: ClassVar[str] = "Items"
+    log_message: ClassVar[str] = "Found {value} items"
+
+    def calculate(self, context: Context, metrics: dict) -> None:
+        cls = type(self)
+        query = self.query(context).filter_by_type(cls.resource_type)
+
+        if cls.count_target == CountTarget.COLUMNS:
+            names = query.column_names(cls.predicate)
+        else:
+            if cls.predicate:
+                query = query.filter(cls.predicate)
+            names = query.names()
+
+        self.value = len(names)
+        if names:
+            self.diagnostic = f"{cls.diagnostic_prefix}: {', '.join(names)}"
+        logger.info(cls.log_message.format(value=self.value))

checkup_dbt-0.2.0/src/checkup_dbt/metrics/core/__init__.py

@@ -0,0 +1,21 @@
+from checkup_dbt.metrics.core.columns import DbtColumnsMetric
+from checkup_dbt.metrics.core.columns_description import (
+    DbtColumnsWithDescriptionMetric,
+    DbtColumnsWithoutDescriptionMetric,
+)
+from checkup_dbt.metrics.core.models import DbtModelsMetric
+from checkup_dbt.metrics.core.models_description import (
+    DbtModelsWithDescriptionMetric,
+    DbtModelsWithoutDescriptionMetric,
+)
+from checkup_dbt.metrics.core.tests import DbtTestsMetric
+
+__all__ = [
+    "DbtModelsMetric",
+    "DbtColumnsMetric",
+    "DbtTestsMetric",
+    "DbtModelsWithDescriptionMetric",
+    "DbtModelsWithoutDescriptionMetric",
+    "DbtColumnsWithDescriptionMetric",
+    "DbtColumnsWithoutDescriptionMetric",
+]

checkup_dbt-0.2.0/src/checkup_dbt/metrics/core/columns.py

@@ -0,0 +1,11 @@
+from typing import ClassVar
+
+from checkup_dbt.metrics.base import CountTarget, DbtCountMetric
+
+
+class DbtColumnsMetric(DbtCountMetric):
+    name: ClassVar[str] = "dbt_columns"
+    description: ClassVar[str] = "Total number of columns across all models"
+    unit: ClassVar[str] = "columns"
+    count_target: ClassVar[CountTarget] = CountTarget.COLUMNS
+    log_message: ClassVar[str] = "Found {value} columns"

checkup_dbt-0.2.0/src/checkup_dbt/metrics/core/columns_description.py

@@ -0,0 +1,25 @@
+from typing import ClassVar
+
+from checkup_dbt.manifest_query import (
+    column_has_description,
+    column_without_description,
+)
+from checkup_dbt.metrics.base import CountTarget, DbtCountMetric
+
+
+class DbtColumnsWithDescriptionMetric(DbtCountMetric):
+    name: ClassVar[str] = "dbt_columns_with_description"
+    description: ClassVar[str] = "Number of columns with descriptions"
+    unit: ClassVar[str] = "columns"
+    count_target: ClassVar[CountTarget] = CountTarget.COLUMNS
+    predicate = column_has_description
+    log_message: ClassVar[str] = "Found {value} columns with descriptions"
+
+
+class DbtColumnsWithoutDescriptionMetric(DbtCountMetric):
+    name: ClassVar[str] = "dbt_columns_without_description"
+    description: ClassVar[str] = "Number of columns without descriptions"
+    unit: ClassVar[str] = "columns"
+    count_target: ClassVar[CountTarget] = CountTarget.COLUMNS
+    predicate = column_without_description
+    log_message: ClassVar[str] = "Found {value} columns without descriptions"

checkup_dbt-0.2.0/src/checkup_dbt/metrics/core/models.py

@@ -0,0 +1,10 @@
+from typing import ClassVar
+
+from checkup_dbt.metrics.base import DbtCountMetric
+
+
+class DbtModelsMetric(DbtCountMetric):
+    name: ClassVar[str] = "dbt_models"
+    description: ClassVar[str] = "Total number of dbt models"
+    unit: ClassVar[str] = "models"
+    log_message: ClassVar[str] = "Found {value} models"

checkup_dbt-0.2.0/src/checkup_dbt/metrics/core/models_description.py

@@ -0,0 +1,20 @@
+from typing import ClassVar
+
+from checkup_dbt.manifest_query import has_description, without_description
+from checkup_dbt.metrics.base import DbtCountMetric
+
+
+class DbtModelsWithDescriptionMetric(DbtCountMetric):
+    name: ClassVar[str] = "dbt_models_with_description"
+    description: ClassVar[str] = "Number of models with descriptions"
+    unit: ClassVar[str] = "models"
+    predicate = has_description
+    log_message: ClassVar[str] = "Found {value} models with descriptions"
+
+
+class DbtModelsWithoutDescriptionMetric(DbtCountMetric):
+    name: ClassVar[str] = "dbt_models_without_description"
+    description: ClassVar[str] = "Number of models without descriptions"
+    unit: ClassVar[str] = "models"
+    predicate = without_description
+    log_message: ClassVar[str] = "Found {value} models without descriptions"

checkup_dbt-0.2.0/src/checkup_dbt/metrics/core/tests.py

@@ -0,0 +1,13 @@
+from typing import ClassVar
+
+from dbt.artifacts.resources.types import NodeType
+
+from checkup_dbt.metrics.base import DbtCountMetric
+
+
+class DbtTestsMetric(DbtCountMetric):
+    name: ClassVar[str] = "dbt_tests"
+    description: ClassVar[str] = "Total number of dbt tests"
+    unit: ClassVar[str] = "tests"
+    resource_type: ClassVar[NodeType] = NodeType.Test
+    log_message: ClassVar[str] = "Found {value} tests"

checkup_dbt-0.2.0/src/checkup_dbt/metrics/output/__init__.py

@@ -0,0 +1,19 @@
+from checkup_dbt.metrics.output.output_columns_without_data_type import (
+    DbtOutputColumnsWithoutDataTypeMetric,
+)
+from checkup_dbt.metrics.output.output_models import DbtOutputModelsMetric
+from checkup_dbt.metrics.output.output_models_description import (
+    DbtOutputModelsWithDescriptionMetric,
+    DbtOutputModelsWithoutDescriptionMetric,
+)
+from checkup_dbt.metrics.output.output_models_without_contracts import (
+    DbtOutputModelsWithoutContractsMetric,
+)
+
+__all__ = [
+    "DbtOutputModelsMetric",
+    "DbtOutputModelsWithDescriptionMetric",
+    "DbtOutputModelsWithoutDescriptionMetric",
+    "DbtOutputModelsWithoutContractsMetric",
+    "DbtOutputColumnsWithoutDataTypeMetric",
+]

checkup_dbt-0.2.0/src/checkup_dbt/metrics/output/output_columns_without_data_type.py

@@ -0,0 +1,16 @@
+from typing import ClassVar
+
+from checkup_dbt.manifest_query import is_output_model
+from checkup_dbt.metrics.base import CountTarget, DbtDiagnosticMetric
+
+
+class DbtOutputColumnsWithoutDataTypeMetric(DbtDiagnosticMetric):
+    name: ClassVar[str] = "dbt_output_columns_without_data_type"
+    description: ClassVar[str] = "Number of columns in output models without data type"
+    unit: ClassVar[str] = "columns"
+    predicate = staticmethod(
+        lambda n, _name, col: is_output_model(n) and col.data_type is None
+    )
+    diagnostic_prefix: ClassVar[str] = "Output columns without data type"
+    log_message: ClassVar[str] = "Found {value} output columns without data type"
+    count_target: ClassVar[CountTarget] = CountTarget.COLUMNS

checkup_dbt-0.2.0/src/checkup_dbt/metrics/output/output_models.py

@@ -0,0 +1,12 @@
+from typing import ClassVar
+
+from checkup_dbt.manifest_query import is_output_model
+from checkup_dbt.metrics.base import DbtCountMetric
+
+
+class DbtOutputModelsMetric(DbtCountMetric):
+    name: ClassVar[str] = "dbt_output_models"
+    description: ClassVar[str] = "Number of output models (non-internal schema)"
+    unit: ClassVar[str] = "models"
+    predicate = is_output_model
+    log_message: ClassVar[str] = "Found {value} output models"