checkup 0.5.3__tar.gz → 0.7.0__tar.gz

{checkup-0.5.3 → checkup-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: checkup
-Version: 0.5.3
+Version: 0.7.0
 Summary: Computational governance framework for measuring data product health
 Author: Jan Vanbuel
 Author-email: Jan Vanbuel <jan.vanbuel@ond.vlaanderen.be>
@@ -32,6 +32,11 @@ Description-Content-Type: text/markdown
   <a href="https://pypi.org/project/checkup/"><img src="https://img.shields.io/pypi/pyversions/checkup" alt="Python versions" /></a>
 </p>
 
+<p align="center">
+  <!-- <img src="https://raw.githubusercontent.com/datamindedbe/checkup/main/images/demo.gif" alt="CheckUp demo" width="100%" /> -->
+  <img src="./images/demo.gif" alt="CheckUp demo" width="100%" />
+</p>
+
 ## Plugins
 
 Checkup uses plugins to provide metrics for different tools and platforms.

{checkup-0.5.3 → checkup-0.7.0}/README.md

@@ -10,6 +10,11 @@
   <a href="https://pypi.org/project/checkup/"><img src="https://img.shields.io/pypi/pyversions/checkup" alt="Python versions" /></a>
 </p>
 
+<p align="center">
+  <!-- <img src="https://raw.githubusercontent.com/datamindedbe/checkup/main/images/demo.gif" alt="CheckUp demo" width="100%" /> -->
+  <img src="./images/demo.gif" alt="CheckUp demo" width="100%" />
+</p>
+
 ## Plugins
 
 Checkup uses plugins to provide metrics for different tools and platforms.

{checkup-0.5.3 → checkup-0.7.0}/pyproject.toml

@@ -1,23 +1,23 @@
 [project]
 name = "checkup"
-version = "0.5.3"
+version = "0.7.0"
 description = "Computational governance framework for measuring data product health"
 readme = "README.md"
 authors = [{ name = "Jan Vanbuel", email = "jan.vanbuel@ond.vlaanderen.be" }]
 requires-python = ">=3.12"
 classifiers = [
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "jinja2>=3.1.6",
-    "pydantic>=2.11.7",
-    "pyyaml>=6.0",
-    "questionary>=2.0",
-    "rich>=13.0",
-    "sqlalchemy>=2.0",
-    "typer>=0.24",
+  "jinja2>=3.1.6",
+  "pydantic>=2.11.7",
+  "pyyaml>=6.0",
+  "questionary>=2.0",
+  "rich>=13.0",
+  "sqlalchemy>=2.0",
+  "typer>=0.24",
 ]
 
 [project.urls]
@@ -32,6 +32,7 @@ checkup = "checkup:main"
 console = "checkup.materializers:ConsoleMaterializer"
 csv = "checkup.materializers:CSVMaterializer"
 html = "checkup.materializers:HTMLMaterializer"
+markdown = "checkup.materializers:MarkdownMaterializer"
 sqlalchemy = "checkup.materializers:SQLAlchemyMaterializer"
 
 [build-system]
@@ -40,23 +41,19 @@ build-backend = "uv_build"
 
 [tool.uv.workspace]
 members = [
-    "plugins/checkup-git",
-    "plugins/checkup-dbt",
-    "plugins/checkup-python",
-    "plugins/checkup-conveyor",
-    "plugins/checkup-gitlab",
-    "plugins/checkup-bitbucket",
-    "plugins/checkup-github",
-    "plugins/checkup-airflow",
+  "plugins/checkup-git",
+  "plugins/checkup-dbt",
+  "plugins/checkup-python",
+  "plugins/checkup-conveyor",
+  "plugins/checkup-gitlab",
+  "plugins/checkup-bitbucket",
+  "plugins/checkup-github",
+  "plugins/checkup-airflow",
 ]
 
 [dependency-groups]
 dev = ["pytest>=9.0.2", "pytest-cov>=7.0.0", "ruff>=0.8.6", "prek>=0.3.0"]
-docs = [
-    "mkdocs>=1.6.0",
-    "mkdocs-material>=9.5.0",
-    "pymdown-extensions>=10.0",
-]
+docs = ["mkdocs>=1.6.0", "mkdocs-material>=9.5.0", "pymdown-extensions>=10.0"]
 
 [tool.pytest.ini_options]
 pythonpath = [".", "tests"]
@@ -68,16 +65,16 @@ line-length = 88
 
 [tool.ruff.lint]
 select = [
-    "E",      # pycodestyle errors
-    "W",      # pycodestyle warnings
-    "F",      # Pyflakes
-    "I",      # isort
-    "B",      # flake8-bugbear
-    "C4",     # flake8-comprehensions
-    "UP",     # pyupgrade
+  "E",  # pycodestyle errors
+  "W",  # pycodestyle warnings
+  "F",  # Pyflakes
+  "I",  # isort
+  "B",  # flake8-bugbear
+  "C4", # flake8-comprehensions
+  "UP", # pyupgrade
 ]
 ignore = [
-    "E501",   # line too long (handled by formatter)
+  "E501", # line too long (handled by formatter)
 ]
 
 [tool.ruff.format]

{checkup-0.5.3 → checkup-0.7.0}/src/checkup/cli/commands/run.py

@@ -36,6 +36,21 @@ def run(
             "--materializer", help="Set materializer (type or type:key=value)"
         ),
     ] = None,
+    select: Annotated[
+        str | None,
+        typer.Option(
+            "--select",
+            "-s",
+            help="Only materialize matching metrics ('method:pattern'). Methods: name (default), tag, type.",
+        ),
+    ] = None,
+    exclude: Annotated[
+        str | None,
+        typer.Option(
+            "--exclude",
+            help="Exclude matching metrics from materialization. Same format as --select.",
+        ),
+    ] = None,
     dry_run: Annotated[
         bool,
         typer.Option("--dry-run", help="Don't materialize, just print"),
@@ -51,6 +66,10 @@ def run(
         bool,
         typer.Option("--verbose", "-v", help="Verbose output"),
     ] = False,
+    quiet: Annotated[
+        bool,
+        typer.Option("--quiet", "-q", help="Only print materializer output to stdout"),
+    ] = False,
 ) -> None:
     """
     Run metrics and materialize results.
@@ -66,4 +85,7 @@ def run(
         cfg,
         materializer="console" if dry_run else materializer,
         multiprocessing=multiprocessing,
+        quiet=quiet,
+        select=select,
+        exclude=exclude,
     )

{checkup-0.5.3 → checkup-0.7.0}/src/checkup/cli/executor.py

@@ -12,6 +12,7 @@ from checkup.hub import CheckHub
 from checkup.materializers import ConsoleMaterializer
 from checkup.providers.tags import TagProvider
 from checkup.registry import get_registry
+from checkup.selection import select_metrics
 
 if TYPE_CHECKING:
     from checkup.materializers import Materializer
@@ -27,6 +28,9 @@ def execute_checkup(
     config: CheckupConfig,
     materializer: str | None = None,
     multiprocessing: bool = True,
+    quiet: bool = False,
+    select: str | None = None,
+    exclude: str | None = None,
 ) -> None:
     """
     Execute checkup with the given configuration.
@@ -35,23 +39,32 @@ def execute_checkup(
         config: Loaded checkup configuration
         materializer: Override materializer type (e.g., "console")
         multiprocessing: If False, run sequentially without subprocesses
+        quiet: If True, send status/errors to stderr so stdout holds only the materializer output.
+        select: Selector for which metrics to materialize.
+        exclude: Selector for metrics to exclude from materialization.
     """
 
+    out = Console(stderr=True) if quiet else console
+
     registry = get_registry()
 
-    providers = _resolve_providers(config, registry)
+    providers = _resolve_providers(config, registry, out)
     if not providers:
-        console.print("[yellow]No providers configured[/yellow]")
+        out.print("[yellow]No providers configured[/yellow]")
         return
 
-    metrics = _resolve_metrics(config, registry)
+    metrics = _resolve_metrics(config, registry, out)
     if not metrics:
-        console.print("[yellow]No metrics configured[/yellow]")
+        out.print("[yellow]No metrics configured[/yellow]")
         return
 
-    materializer = _resolve_materializer(config, registry, materializer)
+    materializer = _resolve_materializer(config, registry, materializer, out)
+
+    select = select if select is not None else config.select
+    exclude = exclude if exclude is not None else config.exclude
+    type_by_name = {mc.instance_name: mc.type for mc in config.metrics}
 
-    console.print(f"[blue]Running {len(metrics)} metrics...[/blue]")
+    out.print(f"[blue]Running {len(metrics)} metrics...[/blue]")
 
     result = (
         CheckHub()
@@ -62,7 +75,23 @@ def execute_checkup(
 
     if result.errors:
         for _, error in result.errors:
-            console.print(f"[red]Error: {error}[/red]")
+            out.print(f"[red]Error: {error}[/red]")
+
+    if select or exclude:
+        selected = select_metrics(
+            metrics,
+            select=select,
+            exclude=exclude,
+            type_resolver=lambda metric: type_by_name.get(metric.name),
+        )
+        result.measurements = [
+            m for m in result.measurements if m.metric.name in selected
+        ]
+        result.direct_metric_names = result.direct_metric_names & selected
+
+        console.print(
+            f"[blue]Materializing {len(selected)} selected of {len(metrics)} total metrics[/blue]"
+        )
 
     result.materialize(materializer)
 
@@ -70,6 +99,7 @@ def execute_checkup(
 def _resolve_providers(
     config: CheckupConfig,
     registry: "PluginRegistry",
+    out: Console = console,
 ) -> list["Provider"]:
     """
     Resolve provider configs to provider instances.
@@ -83,14 +113,14 @@ def _resolve_providers(
     for provider_config in config.providers:
         provider_cls = registry.get_provider(provider_config.name)
         if provider_cls is None:
-            console.print(f"[yellow]Unknown provider: {provider_config.name}[/yellow]")
+            out.print(f"[yellow]Unknown provider: {provider_config.name}[/yellow]")
             continue
 
         try:
             provider = provider_cls(**provider_config.config)
             providers.append(provider)
         except Exception as e:
-            console.print(
+            out.print(
                 f"[red]Failed to instantiate provider {provider_config.name}: {e}[/red]"
             )
 
@@ -100,6 +130,7 @@ def _resolve_providers(
 def _resolve_metrics(
     config: CheckupConfig,
     registry: "PluginRegistry",
+    out: Console = console,
 ) -> list["Metric"]:
     """
     Resolve metric configs to metric instances.
@@ -110,7 +141,7 @@ def _resolve_metrics(
     for metric_config in config.metrics:
         metric_cls = registry.get_metric(metric_config.type)
         if metric_cls is None:
-            console.print(f"[yellow]Unknown metric: {metric_config.type}[/yellow]")
+            out.print(f"[yellow]Unknown metric: {metric_config.type}[/yellow]")
             continue
 
         try:
@@ -121,7 +152,7 @@ def _resolve_metrics(
                 )
             )
         except Exception as e:
-            console.print(
+            out.print(
                 f"[red]Failed to instantiate metric {metric_config.type}: {e}[/red]"
             )
 
@@ -132,6 +163,7 @@ def _resolve_materializer(
     config: CheckupConfig,
     registry: "PluginRegistry",
     override: str | None = None,
+    out: Console = console,
 ) -> "Materializer":
     """
     Resolve materializer config to materializer instance.
@@ -150,13 +182,11 @@ def _resolve_materializer(
     materializer_cls = registry.get_materializer(mat_type)
 
     if materializer_cls is None:
-        console.print(
-            f"[yellow]Unknown materializer: {mat_type}, using console[/yellow]"
-        )
+        out.print(f"[yellow]Unknown materializer: {mat_type}, using console[/yellow]")
         return ConsoleMaterializer()
 
     try:
         return materializer_cls(**mat_config)
     except Exception as e:
-        console.print(f"[red]Failed to instantiate materializer {mat_type}: {e}[/red]")
+        out.print(f"[red]Failed to instantiate materializer {mat_type}: {e}[/red]")
         return ConsoleMaterializer()

{checkup-0.5.3 → checkup-0.7.0}/src/checkup/cli/utils.py

@@ -51,6 +51,8 @@ def apply_cli_overrides(
         providers=new_providers,
         metrics=new_metrics,
         materializer=cfg.materializer,
+        select=cfg.select,
+        exclude=cfg.exclude,
     )
 
 

{checkup-0.5.3 → checkup-0.7.0}/src/checkup/configuration/io.py

@@ -216,4 +216,6 @@ def load_config(
         providers=parse_providers(raw.get("providers")),
         metrics=parse_metrics(raw.get("metrics")),
         materializer=parse_materializer(raw.get("materializer")),
+        select=raw.get("select"),
+        exclude=raw.get("exclude"),
     )

{checkup-0.5.3 → checkup-0.7.0}/src/checkup/configuration/models.py

@@ -8,8 +8,6 @@ from pydantic import BaseModel, Field
 
 
 class ProviderConfig(BaseModel):
-    """Configuration for a single provider."""
-
     name: str
     config: dict[str, Any] = Field(default_factory=dict)
 
@@ -25,19 +23,17 @@ class MetricConfig(BaseModel):
 
 
 class MaterializerConfig(BaseModel):
-    """Configuration for the materializer."""
-
     type: str
     config: dict[str, Any] = Field(default_factory=dict)
 
 
 class CheckupConfig(BaseModel):
-    """Complete checkup configuration."""
-
     tags: dict[str, Any] = Field(default_factory=dict)
     providers: list[ProviderConfig] = Field(default_factory=list)
     metrics: list[MetricConfig] = Field(default_factory=list)
     materializer: MaterializerConfig | None = None
+    select: str | None = None
+    exclude: str | None = None
 
     @classmethod
     def empty(cls) -> "CheckupConfig":

{checkup-0.5.3 → checkup-0.7.0}/src/checkup/configuration/schema.py

@@ -182,6 +182,14 @@ def generate_schema() -> dict:
                 "description": "Tags to identify the data product (e.g., product, team)",
                 "additionalProperties": {"type": "string"},
             },
+            "select": {
+                "type": "string",
+                "description": "Default selector for materialized output.",
+            },
+            "exclude": {
+                "type": "string",
+                "description": "Default selector for materialization to exclude.",
+            },
             "providers": {
                 "type": "array",
                 "description": "Data providers for context enrichment",

{checkup-0.5.3 → checkup-0.7.0}/src/checkup/materializers/__init__.py

@@ -9,11 +9,13 @@ from checkup.materializers.console import ConsoleMaterializer
 from checkup.materializers.csv_file import CSVMaterializer
 from checkup.materializers.database import SQLAlchemyMaterializer
 from checkup.materializers.html_report import HTMLMaterializer
+from checkup.materializers.markdown import MarkdownMaterializer
 
 __all__ = [
     "ConsoleMaterializer",
     "CSVMaterializer",
     "HTMLMaterializer",
+    "MarkdownMaterializer",
     "Materializer",
     "SQLAlchemyMaterializer",
     "group_measurements_by_tags",

checkup-0.7.0/src/checkup/materializers/markdown.py

@@ -0,0 +1,52 @@
+"""Markdown materializer for Markdown table output."""
+
+from checkup.materializers.base import Materializer
+from checkup.measurement import Measurement
+
+COLUMNS = ("Name", "Description", "Value", "Unit", "Diagnostics")
+ALIGNMENTS = ("---", "---", "---:", "---", "---")  # Right-align the Value column.
+
+
+class MarkdownMaterializer(Materializer):
+    """
+    Output measurements as a GitHub-flavoured Markdown table.
+    """
+
+    def materialize(
+        self, measurements: list[Measurement], direct_metric_names: set[str]
+    ) -> None:
+        """
+        Print measurements as a Markdown table.
+        """
+
+        filtered = self._filter_measurements(measurements, direct_metric_names)
+
+        rows = [self._row(COLUMNS), self._row(ALIGNMENTS)]
+        for measurement in filtered:
+            rows.append(
+                self._row(
+                    (
+                        measurement.metric.name,
+                        measurement.metric.description,
+                        str(measurement.value) if measurement.value is not None else "",
+                        measurement.metric.unit,
+                        measurement.diagnostic,
+                    )
+                )
+            )
+        print("\n".join(rows))
+
+    @classmethod
+    def _row(cls, cells: tuple[str, ...]) -> str:
+        return "| " + " | ".join(cls._cell(cell) for cell in cells) + " |"
+
+    @staticmethod
+    def _cell(value: str) -> str:
+        """
+        Escape a value for a Markdown table cell.
+
+        Cells cannot contain a raw pipe (column separator) or newline (row separator),
+        so escape pipes and turn newlines into `<br>`.
+        """
+
+        return str(value or "").replace("|", "\\|").replace("\n", "<br>").strip()

{checkup-0.5.3 → checkup-0.7.0}/src/checkup/metric.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from enum import Enum
 from typing import TYPE_CHECKING, Any
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from checkup.types import Context
 
@@ -44,6 +44,7 @@ class Metric(ABC, BaseModel):
     name: str
     description: str = ""
     unit: str = ""
+    tags: list[str] = Field(default_factory=list)
 
     model_config = {"frozen": True}
 

checkup-0.7.0/src/checkup/selection.py

@@ -0,0 +1,103 @@
+"""
+Metric selection for filtering materialized output.
+
+Selection filters which measurements get materialized, it never changes what
+is calculated, dependencies are always computed.
+
+A selector is a set of whitespace-separated atoms (a union).
+Each atom is ``[method:]pattern`` where:
+
+- ``method`` is ``name`` (the default), ``tag`` or ``type``
+- ``pattern`` supports ``*`` wildcards
+
+Examples::
+
+    healthcheck_*
+    name:healthcheck_*
+    tag:healthcheck
+    type:git_tracked_file_count tag:healthcheck
+"""
+
+import fnmatch
+from collections.abc import Callable, Iterable
+from enum import StrEnum
+from typing import assert_never
+
+from checkup.metric import Metric
+
+
+class SelectionMethod(StrEnum):
+    NAME = "name"
+    TAG = "tag"
+    TYPE = "type"
+
+
+# Resolves a metric instance to its registered type name.
+# Names are needed by the filter, with a resolver being offered as argument
+# because the name-type mapping is defined by the config.
+TypeResolver = Callable[[Metric], str | None]
+
+
+def select_metrics(
+    metrics: Iterable[Metric],
+    select: str | None = None,
+    exclude: str | None = None,
+    type_resolver: TypeResolver | None = None,
+) -> set[str]:
+    """
+    Return the names of the metrics whose measurements should be materialized.
+
+    With no ``select`` every metric is included;
+    ``exclude`` (if given) is then removed from the set.
+    """
+
+    metrics = list(metrics)
+    type_resolver = type_resolver or (lambda _name: None)
+
+    if select:
+        selected = _match_selector(select, metrics, type_resolver)
+    else:
+        selected = {metric.name for metric in metrics}
+
+    if exclude:
+        selected -= _match_selector(exclude, metrics, type_resolver)
+
+    return selected
+
+
+def _match_selector(
+    selector: str,
+    metrics: list[Metric],
+    type_resolver: TypeResolver,
+) -> set[str]:
+    atoms = selector.split()
+    return {
+        metric.name
+        for metric in metrics
+        if any(_match_atom(atom, metric, type_resolver) for atom in atoms)
+    }
+
+
+def _match_atom(
+    atom: str,
+    metric: Metric,
+    type_resolver: TypeResolver,
+    *,
+    default_method: SelectionMethod = SelectionMethod.NAME,
+) -> bool:
+    method_name, separator, pattern = atom.partition(":")
+    if not separator:
+        method, pattern = default_method, atom
+    else:
+        method = SelectionMethod(method_name)
+
+    match method:
+        case SelectionMethod.NAME:
+            return fnmatch.fnmatch(metric.name, pattern)
+        case SelectionMethod.TAG:
+            return any(fnmatch.fnmatch(tag, pattern) for tag in metric.tags)
+        case SelectionMethod.TYPE:
+            metric_type = type_resolver(metric)
+            return metric_type is not None and fnmatch.fnmatch(metric_type, pattern)
+        case _:
+            assert_never(method)