checkup 0.3.0__tar.gz → 0.5.0__tar.gz

{checkup-0.3.0 → checkup-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: checkup
-Version: 0.3.0
+Version: 0.5.0
 Summary: Computational governance framework for measuring data product health
 Author: Jan Vanbuel
 Author-email: Jan Vanbuel <jan.vanbuel@ond.vlaanderen.be>

{checkup-0.3.0 → checkup-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "checkup"
-version = "0.3.0"
+version = "0.5.0"
 description = "Computational governance framework for measuring data product health"
 readme = "README.md"
 authors = [{ name = "Jan Vanbuel", email = "jan.vanbuel@ond.vlaanderen.be" }]

{checkup-0.3.0 → checkup-0.5.0}/src/checkup/__init__.py

@@ -14,18 +14,23 @@ from checkup.materializers import (
     Materializer,
     SQLAlchemyMaterializer,
 )
-from checkup.metric import ExecutorType, Measurement, Metric
+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",

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

@@ -0,0 +1,38 @@
+"""
+Checkup CLI application.
+"""
+
+from importlib.metadata import version as pkg_version
+from typing import Annotated
+
+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,
+)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(pkg_version("checkup"))
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool | None,
+        typer.Option("--version", "-v", callback=version_callback),
+    ] = None,
+) -> None:
+    pass
+
+
+app.command()(run)
+app.command()(init)
+app.command()(config)
+app.command()(schema)

{checkup-0.3.0 → checkup-0.5.0}/src/checkup/cli/config_wizard/create.py

@@ -79,7 +79,7 @@ def _build_config(registry: "PluginRegistry") -> CheckupConfig | None:
     return CheckupConfig(
         tags=tags,
         providers=[ProviderConfig(name=p) for p in provider_names],
-        metrics=[MetricConfig(name=m) for m in metric_names],
+        metrics=[MetricConfig(type=m) for m in metric_names],
         materializer=MaterializerConfig(type=mat) if mat != "console" else None,
     )
 

{checkup-0.3.0 → checkup-0.5.0}/src/checkup/cli/config_wizard/edit.py

@@ -58,7 +58,7 @@ def _build_config(
     config: CheckupConfig, registry: "PluginRegistry"
 ) -> CheckupConfig | None:
     provider_configs = {p.name: p.config for p in config.providers}
-    metric_configs = {m.name: m.config for m in config.metrics}
+    metric_configs = {m.type: m.config for m in config.metrics}
 
     tags = _prompt_edit_tags(config)
     if tags is None:
@@ -83,7 +83,7 @@ def _build_config(
             for p in provider_names
         ],
         metrics=[
-            MetricConfig(name=m, config=metric_configs.get(m, {})) for m in metric_names
+            MetricConfig(type=m, config=metric_configs.get(m, {})) for m in metric_names
         ],
         materializer=MaterializerConfig(type=mat) if mat else None,
     )
@@ -121,7 +121,7 @@ def _prompt_edit_metrics(
     registry: "PluginRegistry",
     provider_names: list[str],
 ) -> list[str] | None:
-    current_names = [m.name for m in config.metrics]
+    current_types = [m.type for m in config.metrics]
 
     with console.status("Loading metrics..."):
         available = registry.list_compatible_metric_names(provider_names)
@@ -130,8 +130,8 @@ def _prompt_edit_metrics(
     if edit is None:
         return None
     elif edit:
-        return select_multiple(available, current_names, "metrics")
-    return [m.name for m in config.metrics if m.name in available]
+        return select_multiple(available, current_types, "metrics")
+    return [m.type for m in config.metrics if m.type in available]
 
 
 def _prompt_edit_materializer(
@@ -194,7 +194,7 @@ def _show_current_config(config: "CheckupConfig") -> None:
     console.print("[bold]Current configuration:[/bold]", markup=True)
     console.print(f"  Tags: {dict(config.tags) or '(none)'}")
     console.print(f"  Providers: {[p.name for p in config.providers] or '(none)'}")
-    console.print(f"  Metrics: {[m.name for m in config.metrics] or '(none)'}")
+    console.print(f"  Metrics: {[m.type for m in config.metrics] or '(none)'}")
     mat = config.materializer.type if config.materializer else "(none)"
     console.print(f"  Materializer: {mat}")
     console.print()

{checkup-0.3.0 → checkup-0.5.0}/src/checkup/cli/executor.py

@@ -98,17 +98,21 @@ def _resolve_metrics(
     metrics: list[Metric] = []
 
     for metric_config in config.metrics:
-        metric_cls = registry.get_metric(metric_config.name)
+        metric_cls = registry.get_metric(metric_config.type)
         if metric_cls is None:
-            console.print(f"[yellow]Unknown metric: {metric_config.name}[/yellow]")
+            console.print(f"[yellow]Unknown metric: {metric_config.type}[/yellow]")
             continue
 
         try:
-            metric = metric_cls(**metric_config.config)
-            metrics.append(metric)
+            metrics.append(
+                metric_cls(
+                    **metric_config.config,
+                    **({"name": metric_config.name} if metric_config.name else {}),
+                )
+            )
         except Exception as e:
             console.print(
-                f"[red]Failed to instantiate metric {metric_config.name}: {e}[/red]"
+                f"[red]Failed to instantiate metric {metric_config.type}: {e}[/red]"
             )
 
     return metrics

{checkup-0.3.0 → checkup-0.5.0}/src/checkup/cli/utils.py

@@ -41,8 +41,8 @@ def apply_cli_overrides(
     if metrics:
         new_metrics = []
         for m in metrics:
-            name, config = parse_cli_item(m)
-            new_metrics.append(MetricConfig(name=name, config=config))
+            metric_type, config = parse_cli_item(m)
+            new_metrics.append(MetricConfig(type=metric_type, config=config))
     else:
         new_metrics = list(cfg.metrics)
 

{checkup-0.3.0 → checkup-0.5.0}/src/checkup/configuration/io.py

@@ -80,13 +80,17 @@ def merge_configs(base: dict[str, Any], override: dict[str, Any]) -> dict[str, A
             result[key] = value
         elif key == "metrics":
             if key in result:
-                base_metrics = {
-                    (m if isinstance(m, str) else list(m.keys())[0]): m
-                    for m in result.get(key, [])
-                }
+
+                def _metric_key(m: dict) -> tuple:
+                    """
+                    Key by (type, name) to allow multiple instances of same type
+                    """
+
+                    return (m.get("type"), m.get("name"))
+
+                base_metrics = {_metric_key(m): m for m in result.get(key, [])}
                 for metric in value:
-                    name = metric if isinstance(metric, str) else list(metric.keys())[0]
-                    base_metrics[name] = metric
+                    base_metrics[_metric_key(metric)] = metric
                 result[key] = list(base_metrics.values())
             else:
                 result[key] = value
@@ -126,9 +130,10 @@ def parse_metrics(raw: list[Any] | None) -> list[MetricConfig]:
     Parse metric configuration from raw YAML.
 
     Supports:
-        - name: git_days_since_last_update
-        - name: python_version
-          version: "3.12"
+        - type: git_tracked_file_count
+        - type: git_tracked_file_count
+          name: cruft_file_exists
+          pattern: ".cruft.json"
     """
 
     if not raw:
@@ -136,13 +141,14 @@ def parse_metrics(raw: list[Any] | None) -> list[MetricConfig]:
 
     metrics = []
     for item in raw:
-        if isinstance(item, str):
-            metrics.append(MetricConfig(name=item))
-        elif isinstance(item, dict):
-            name = item.get("name")
-            if name:
-                config = {k: v for k, v in item.items() if k != "name"}
-                metrics.append(MetricConfig(name=name, config=config))
+        if not isinstance(item, dict):
+            continue
+        metric_type = item.get("type")
+        if not metric_type:
+            continue
+        name = item.get("name")
+        config = {k: v for k, v in item.items() if k not in ("type", "name")}
+        metrics.append(MetricConfig(type=metric_type, name=name, config=config))
     return metrics
 
 

{checkup-0.3.0 → checkup-0.5.0}/src/checkup/configuration/models.py

@@ -15,11 +15,14 @@ class ProviderConfig(BaseModel):
 
 
 class MetricConfig(BaseModel):
-    """Configuration for a single metric."""
-
-    name: str
+    type: str
+    name: str | None = None
     config: dict[str, Any] = Field(default_factory=dict)
 
+    @property
+    def instance_name(self) -> str:
+        return self.name or self.type
+
 
 class MaterializerConfig(BaseModel):
     """Configuration for the materializer."""

{checkup-0.3.0 → checkup-0.5.0}/src/checkup/configuration/schema.py

@@ -190,7 +190,9 @@ def generate_schema() -> dict:
             "metrics": {
                 "type": "array",
                 "description": "Metrics to calculate",
-                "items": _build_oneof_schema(metric_names, metric_schemas),
+                "items": _build_oneof_schema(
+                    metric_names, metric_schemas, key_field="type"
+                ),
             },
             "materializer": _build_oneof_schema(
                 materializer_names, materializer_schemas, key_field="type"

{checkup-0.3.0 → checkup-0.5.0}/src/checkup/errors.py

@@ -27,7 +27,7 @@ class MetricPicklingError(Exception):
         self.metric_cls = metric_cls
         self.original_error = original_error
         super().__init__(
-            f"Metric '{metric_cls.name}' cannot be pickled for process execution. "
+            f"Metric '{metric_cls.__name__}' cannot be pickled for process execution. "
             f"Consider using ExecutorType.THREAD instead. Original error: {original_error}"
         )
 
@@ -39,15 +39,14 @@ class MetricPicklingError(Exception):
 class DuplicateMetricNameError(Exception):
     """Exception raised when multiple metrics have the same name."""
 
-    def __init__(self, name: str, metric_classes: "list[type[Metric]]"):
-        self.name = name
-        self.metric_classes = metric_classes
-        class_names = ", ".join(cls.__name__ for cls in metric_classes)
-        super().__init__(
-            f"Duplicate metric name '{name}' found in classes: {class_names}. "
-            f"Each metric must have a unique name."
-        )
+    def __init__(self, duplicates: "dict[str, list[type[Metric]]]"):
+        self.duplicates = duplicates
+        lines = []
+        for name, classes in duplicates.items():
+            class_names = ", ".join(cls.__name__ for cls in classes)
+            lines.append(f"  '{name}': {class_names}")
+        super().__init__("Duplicate metric names found:\n" + "\n".join(lines))
 
     def __reduce__(self):
         """Enable pickling across process boundaries."""
-        return (self.__class__, (self.name, self.metric_classes))
+        return (self.__class__, (self.duplicates,))

checkup-0.5.0/src/checkup/executor/__init__.py

@@ -0,0 +1,6 @@
+"""Executor classes for provider and metric execution."""
+
+from checkup.executor.metric_calculator import MetricCalculator
+from checkup.executor.provider_executor import ProviderExecutor
+
+__all__ = ["MetricCalculator", "ProviderExecutor"]

checkup-0.5.0/src/checkup/executor/batch_executors.py

@@ -0,0 +1,169 @@
+"""Batch execution strategies for different executor types."""
+
+import asyncio
+import inspect
+import logging
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
+from typing import Any
+
+from checkup.measurement import Measurement, Measurements
+from checkup.metric import Metric
+from checkup.types import Context
+from checkup.validators import validate_pickleable
+
+logger = logging.getLogger(__name__)
+
+
+def _calculate_metric_in_process(
+    metric: Metric,
+    context: Context,
+    tags: dict[str, Any],
+    calculated: Measurements,
+) -> Measurement:
+    """
+    Calculate a single metric in a subprocess.
+
+    Module-level function for ProcessPoolExecutor compatibility.
+    """
+
+    measurement = metric.calculate(context, calculated)
+    measurement.tags.update(tags)
+    return measurement
+
+
+def execute_batch_thread(
+    batch: list[Metric],
+    context: Context,
+    tags: dict[str, Any],
+    calculated: Measurements,
+) -> list[tuple[Metric, Measurement]]:
+    """
+    Execute metrics using ThreadPoolExecutor.
+    """
+
+    results: list[tuple[Metric, Measurement]] = []
+
+    with ThreadPoolExecutor(max_workers=len(batch)) as executor:
+        future_to_metric = {
+            executor.submit(
+                _calculate_single_metric,
+                metric,
+                context,
+                tags,
+                calculated,
+            ): metric
+            for metric in batch
+        }
+
+        for future in as_completed(future_to_metric):
+            metric = future_to_metric[future]
+            measurement = future.result()
+            results.append((metric, measurement))
+
+    return results
+
+
+def execute_batch_process(
+    batch: list[Metric],
+    context: Context,
+    tags: dict[str, Any],
+    calculated: Measurements,
+) -> list[tuple[Metric, Measurement]]:
+    """
+    Execute metrics using ProcessPoolExecutor.
+    """
+
+    for metric in batch:
+        validate_pickleable(type(metric))
+
+    results: list[tuple[Metric, Measurement]] = []
+
+    with ProcessPoolExecutor(max_workers=len(batch)) as executor:
+        future_to_metric = {
+            executor.submit(
+                _calculate_metric_in_process,
+                metric,
+                context,
+                tags,
+                calculated,
+            ): metric
+            for metric in batch
+        }
+
+        for future in as_completed(future_to_metric):
+            metric = future_to_metric[future]
+            try:
+                measurement = future.result()
+                results.append((metric, measurement))
+            except Exception as e:
+                logger.error(
+                    "Metric %s failed in process executor: %s",
+                    metric.name,
+                    e,
+                )
+                raise
+
+    return results
+
+
+def execute_batch_asyncio(
+    batch: list[Metric],
+    context: Context,
+    tags: dict[str, Any],
+    calculated: Measurements,
+) -> list[tuple[Metric, Measurement]]:
+    """
+    Execute metrics using asyncio.
+    """
+
+    return asyncio.run(_execute_batch_asyncio_impl(batch, context, tags, calculated))
+
+
+async def _execute_batch_asyncio_impl(
+    batch: list[Metric],
+    context: Context,
+    tags: dict[str, Any],
+    calculated: Measurements,
+) -> list[tuple[Metric, Measurement]]:
+    """
+    Async implementation of batch execution.
+    """
+
+    tasks = [
+        _calculate_async_metric(metric, context, tags, calculated) for metric in batch
+    ]
+    measurements = await asyncio.gather(*tasks)
+    return list(zip(batch, measurements, strict=True))
+
+
+async def _calculate_async_metric(
+    metric: Metric,
+    context: Context,
+    tags: dict[str, Any],
+    calculated: Measurements,
+) -> Measurement:
+    """
+    Calculate a single metric, handling both sync and async calculate methods.
+    """
+
+    if inspect.iscoroutinefunction(metric.calculate):
+        measurement = await metric.calculate(context, calculated)
+    else:
+        measurement = metric.calculate(context, calculated)
+    measurement.tags.update(tags)
+    return measurement
+
+
+def _calculate_single_metric(
+    metric: Metric,
+    context: Context,
+    tags: dict[str, Any],
+    calculated: Measurements,
+) -> Measurement:
+    """
+    Calculate a single metric (for thread executor).
+    """
+
+    measurement = metric.calculate(context, calculated)
+    measurement.tags.update(tags)
+    return measurement