checkup 0.2.10__tar.gz → 0.4.0__tar.gz

{checkup-0.2.10 → checkup-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: checkup
-Version: 0.2.10
+Version: 0.4.0
 Summary: Computational governance framework for measuring data product health
 Author: Jan Vanbuel
 Author-email: Jan Vanbuel <jan.vanbuel@ond.vlaanderen.be>
@@ -10,8 +10,10 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: questionary>=2.0
 Requires-Dist: rich>=13.0
 Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: typer>=0.24
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 

{checkup-0.2.10 → checkup-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "checkup"
-version = "0.2.10"
+version = "0.4.0"
 description = "Computational governance framework for measuring data product health"
 readme = "README.md"
 authors = [{ name = "Jan Vanbuel", email = "jan.vanbuel@ond.vlaanderen.be" }]
@@ -14,13 +14,21 @@ dependencies = [
     "jinja2>=3.1.6",
     "pydantic>=2.11.7",
     "pyyaml>=6.0",
+    "questionary>=2.0",
     "rich>=13.0",
     "sqlalchemy>=2.0",
+    "typer>=0.24",
 ]
 
 [project.scripts]
 checkup = "checkup:main"
 
+[project.entry-points."checkup.materializers"]
+console = "checkup.materializers:ConsoleMaterializer"
+csv = "checkup.materializers:CSVMaterializer"
+html = "checkup.materializers:HTMLMaterializer"
+sqlalchemy = "checkup.materializers:SQLAlchemyMaterializer"
+
 [build-system]
 requires = ["uv_build>=0.8.13,<0.9.0"]
 build-backend = "uv_build"

{checkup-0.2.10 → checkup-0.4.0}/src/checkup/__init__.py

@@ -1,4 +1,4 @@
-"""Checkup - Extensible metrics calculation framework."""
+"""Checkup - Computational governance framework for measuring data product health."""
 
 from checkup.errors import (
     DuplicateMetricNameError,
@@ -14,17 +14,23 @@ from checkup.materializers import (
     Materializer,
     SQLAlchemyMaterializer,
 )
+from checkup.measurement import Measurement, Measurements
 from checkup.metric import ExecutorType, Metric
 from checkup.provider import Provider
 from checkup.providers.tags import TagProvider
 from checkup.types import Context
 from checkup.utils import suppress_subprocess_output
 
+# Rebuild models to resolve forward references after all classes are imported
+Measurement.model_rebuild()
+
 __all__ = [
     # Core
     "CheckHub",
     "MeasurementResult",
     "Metric",
+    "Measurement",
+    "Measurements",
     "ExecutorType",
     "Provider",
     "TagProvider",
@@ -48,6 +54,6 @@ __all__ = [
 
 
 def main() -> None:
-    """CLI entry point."""
-    print("Checkup metrics framework")
-    print("Import CheckHub to get started")
+    from checkup.cli import app
+
+    app()

checkup-0.4.0/src/checkup/cli/__init__.py

@@ -0,0 +1,18 @@
+"""
+Checkup CLI application.
+"""
+
+import typer
+
+from checkup.cli.commands import config, init, run, schema
+
+app = typer.Typer(
+    name="checkup",
+    help="CheckUp - Computational governance framework for measuring data product health",
+    no_args_is_help=True,
+)
+
+app.command()(run)
+app.command()(init)
+app.command()(config)
+app.command()(schema)

checkup-0.4.0/src/checkup/cli/commands/__init__.py

@@ -0,0 +1,15 @@
+"""
+CLI commands.
+"""
+
+from checkup.cli.commands.config import config
+from checkup.cli.commands.init import init
+from checkup.cli.commands.run import run
+from checkup.cli.commands.schema import schema
+
+__all__ = [
+    "config",
+    "init",
+    "run",
+    "schema",
+]

checkup-0.4.0/src/checkup/cli/commands/config.py

@@ -0,0 +1,23 @@
+"""
+Config command. Modify an existing config file.
+"""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from checkup.cli.config_wizard import edit_config
+
+
+def config(
+    config_path: Annotated[
+        Path | None,
+        typer.Option("--config", "-c", help="Path to config file"),
+    ] = None,
+) -> None:
+    """
+    Modify the checkup.yaml config file.
+    """
+
+    edit_config(config_path=config_path)

checkup-0.4.0/src/checkup/cli/commands/init.py

@@ -0,0 +1,23 @@
+"""
+Init command. Create a new config file.
+"""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from checkup.cli.config_wizard import create_config
+
+
+def init(
+    output: Annotated[
+        Path | None,
+        typer.Option("--output", "-o", help="Output path for config file"),
+    ] = None,
+) -> None:
+    """
+    Create a checkup.yaml config file.
+    """
+
+    create_config(output_path=output)

checkup-0.4.0/src/checkup/cli/commands/run.py

@@ -0,0 +1,58 @@
+"""
+Run command. Run metrics and materialize results.
+"""
+
+import logging
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from checkup.cli.executor import execute_checkup
+from checkup.cli.utils import apply_cli_overrides
+from checkup.configuration import load_config
+
+
+def run(
+    config: Annotated[
+        Path | None,
+        typer.Option("--config", "-c", help="Path to config file"),
+    ] = None,
+    tag: Annotated[
+        list[str] | None,
+        typer.Option("--tag", "-t", help="Set tags (key=value)"),
+    ] = None,
+    provider: Annotated[
+        list[str] | None,
+        typer.Option("--provider", "-p", help="Set providers (name or name:key=value)"),
+    ] = None,
+    metric: Annotated[
+        list[str] | None,
+        typer.Option("--metric", "-m", help="Set metrics (name or name:key=value)"),
+    ] = None,
+    materializer: Annotated[
+        str | None,
+        typer.Option(
+            "--materializer", help="Set materializer (type or type:key=value)"
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Don't materialize, just print"),
+    ] = False,
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="Verbose output"),
+    ] = False,
+) -> None:
+    """
+    Run metrics and materialize results.
+    """
+
+    if verbose:
+        logging.basicConfig(level=logging.DEBUG)
+
+    cfg = load_config(config_path=config)
+    cfg = apply_cli_overrides(cfg, tag, provider, metric)
+
+    execute_checkup(cfg, materializer="console" if dry_run else materializer)

checkup-0.4.0/src/checkup/cli/commands/schema.py

@@ -0,0 +1,29 @@
+"""
+Schema command. Generate JSON schema for checkup.yaml.
+"""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from checkup.configuration.io import SCHEMA_FILENAME
+from checkup.configuration.schema import write_schema
+
+console = Console()
+
+
+def schema(
+    output: Annotated[
+        Path | None,
+        typer.Option("--output", "-o", help="Output path for schema file"),
+    ] = None,
+) -> None:
+    """
+    Generate JSON schema for checkup.yaml.
+    """
+
+    path = output or Path.cwd() / SCHEMA_FILENAME
+    write_schema(path)
+    console.print(f"[green]Schema written to {path}[/green]")

checkup-0.4.0/src/checkup/cli/config_wizard/__init__.py

@@ -0,0 +1,8 @@
+"""
+Interactive config generation and editing.
+"""
+
+from .create import create_config
+from .edit import edit_config
+
+__all__ = ["create_config", "edit_config"]

checkup-0.4.0/src/checkup/cli/config_wizard/_common.py

@@ -0,0 +1,133 @@
+"""
+Shared utilities for the config wizard.
+"""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import yaml
+from rich.console import Console
+
+from checkup.configuration.io import SCHEMA_FILENAME
+from checkup.configuration.models import CheckupConfig
+from checkup.configuration.schema import write_schema
+
+if TYPE_CHECKING:
+    import questionary
+
+    from checkup.registry import PluginRegistry
+
+console = Console(markup=False, highlight=False)
+
+
+def get_questionary() -> "questionary":
+    """
+    Lazy import questionary to avoid slow startup.
+    """
+
+    import questionary
+
+    return questionary
+
+
+def select_multiple(
+    available: list[str],
+    selected: list[str],
+    item_name: str,
+) -> list[str]:
+    """
+    Select multiple items with fuzzy search.
+    """
+
+    if not available:
+        console.print(
+            f"[yellow]No {item_name} found. Install checkup plugins.[/yellow]",
+            markup=True,
+        )
+        return []
+
+    selected_count = len([s for s in selected if s in available])
+    console.print(f"Currently selected: {selected_count}/{len(available)} {item_name}")
+
+    choices = [
+        get_questionary().Choice(name, checked=name in selected)
+        for name in sorted(available)
+    ]
+
+    result = (
+        get_questionary()
+        .checkbox(
+            f"Select {item_name}:",
+            choices=choices,
+            use_search_filter=True,
+            use_jk_keys=False,
+            instruction="(↑↓ navigate, space toggle, type to filter, enter confirm)",
+        )
+        .ask()
+    )
+
+    return result or []
+
+
+def select_materializer(current: str | None, registry: "PluginRegistry") -> str | None:
+    """
+    Select materializer interactively.
+    """
+
+    available = registry.list_materializer_names()
+
+    if not available:
+        return "console"
+
+    default = (
+        current if current in available else (available[0] if available else "console")
+    )
+
+    return (
+        get_questionary()
+        .select(
+            "Materializer type:",
+            choices=available,
+            default=default,
+            use_search_filter=True,
+            use_jk_keys=False,
+        )
+        .ask()
+    )
+
+
+def write_config(path: Path, config: CheckupConfig) -> None:
+    """
+    Write config to file with empty lines between sections.
+    Also generates the JSON schema file.
+    """
+
+    console.print(f"\n[bold]Writing config to {path}[/bold]", markup=True)
+
+    data = config.model_dump(exclude_defaults=True)
+
+    lines = [f"# yaml-language-server: $schema={SCHEMA_FILENAME}"]
+
+    # Write sections separately with blank lines between them
+    for key in CheckupConfig.model_fields:
+        if key not in data or not data[key]:
+            continue
+        lines.append("")
+        lines.append(
+            yaml.dump(
+                {key: data[key]}, default_flow_style=False, sort_keys=False
+            ).rstrip()
+        )
+
+    with open(path, "w") as f:
+        f.write("\n".join(lines))
+        f.write("\n")
+
+    schema_path = path.parent / SCHEMA_FILENAME
+    write_schema(schema_path)
+    console.print(f"[green]Schema written to {schema_path}[/green]", markup=True)
+
+    console.print("[green]Done![/green]", markup=True)
+    console.print(
+        "Run [bold]checkup run[/bold] to test your configuration.", markup=True
+    )

checkup-0.4.0/src/checkup/cli/config_wizard/create.py

@@ -0,0 +1,134 @@
+"""
+Interactive config creation.
+"""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from checkup.configuration.io import CONFIG_FILENAME
+from checkup.configuration.models import (
+    CheckupConfig,
+    MaterializerConfig,
+    MetricConfig,
+    ProviderConfig,
+)
+from checkup.registry import get_registry
+
+from ._common import (
+    console,
+    get_questionary,
+    select_materializer,
+    select_multiple,
+    write_config,
+)
+
+if TYPE_CHECKING:
+    from checkup.registry import PluginRegistry
+
+
+def create_config(output_path: Path | None = None) -> None:
+    """
+    Interactively create a new config file.
+    """
+
+    path = output_path or Path.cwd() / CONFIG_FILENAME
+
+    if not _confirm_overwrite(path):
+        return
+
+    registry = get_registry()
+    config = _build_config(registry)
+
+    if config is None:
+        console.print("\n[yellow]Cancelled.[/yellow]", markup=True)
+        return
+
+    write_config(path, config)
+
+
+def _confirm_overwrite(path: Path) -> bool:
+    if not path.exists():
+        return True
+
+    overwrite = (
+        get_questionary().confirm(f"{path} exists. Overwrite?", default=False).ask()
+    )
+    if overwrite is None:
+        console.print("\n[yellow]Cancelled.[/yellow]", markup=True)
+        return False
+    return overwrite
+
+
+def _build_config(registry: "PluginRegistry") -> CheckupConfig | None:
+    tags = _prompt_tags()
+    if tags is None:
+        return None
+
+    provider_names = _prompt_providers(registry)
+    if provider_names is None:
+        return None
+
+    metric_names = _prompt_metrics(registry, provider_names)
+    if metric_names is None:
+        return None
+
+    mat = _prompt_materializer(registry)
+    if mat is None:
+        return None
+
+    return CheckupConfig(
+        tags=tags,
+        providers=[ProviderConfig(name=p) for p in provider_names],
+        metrics=[MetricConfig(type=m) for m in metric_names],
+        materializer=MaterializerConfig(type=mat) if mat != "console" else None,
+    )
+
+
+def _prompt_tags() -> dict[str, str] | None:
+    console.print("\n[bold]Tags[/bold]", markup=True)
+    console.print(
+        "Tags identify your data product (e.g., product=my-product, team=analytics)"
+    )
+    return _collect_tags()
+
+
+def _prompt_providers(registry: "PluginRegistry") -> list[str] | None:
+    console.print("\n[bold]Providers[/bold]", markup=True)
+    return select_multiple(registry.list_provider_names(), [], "providers")
+
+
+def _prompt_metrics(
+    registry: "PluginRegistry", provider_names: list[str]
+) -> list[str] | None:
+    console.print("\n[bold]Metrics[/bold]", markup=True)
+    with console.status("Loading metrics..."):
+        available_metrics = registry.list_compatible_metric_names(provider_names)
+    return select_multiple(available_metrics, [], "metrics")
+
+
+def _prompt_materializer(registry: "PluginRegistry") -> str | None:
+    console.print("\n[bold]Materializer[/bold]", markup=True)
+    return select_materializer(None, registry)
+
+
+def _collect_tags() -> dict[str, str] | None:
+    tags: dict[str, str] = {}
+
+    while True:
+        tag: str = (
+            get_questionary()
+            .text(
+                "Add tag (key=value, or empty to finish):",
+            )
+            .ask()
+        )
+
+        if tag is None:
+            return None
+        if not tag:
+            break
+        if "=" in tag:
+            key, value = tag.split("=", 1)
+            tags[key.strip()] = value.strip()
+
+    return tags