checkup 0.5.0__tar.gz → 0.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: checkup
-Version: 0.5.0
+Version: 0.5.2
 Summary: Computational governance framework for measuring data product health
 Author: Jan Vanbuel
 Author-email: Jan Vanbuel <jan.vanbuel@ond.vlaanderen.be>
@@ -15,6 +15,9 @@ Requires-Dist: rich>=13.0
 Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: typer>=0.24
 Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/datamindedbe/checkup
+Project-URL: Issues, https://github.com/datamindedbe/checkup/issues
+Project-URL: Source, https://github.com/datamindedbe/checkup
 Description-Content-Type: text/markdown
 
 # CheckUp

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

@@ -1,6 +1,6 @@
 [project]
 name = "checkup"
-version = "0.5.0"
+version = "0.5.2"
 description = "Computational governance framework for measuring data product health"
 readme = "README.md"
 authors = [{ name = "Jan Vanbuel", email = "jan.vanbuel@ond.vlaanderen.be" }]
@@ -20,6 +20,11 @@ dependencies = [
     "typer>=0.24",
 ]
 
+[project.urls]
+Homepage = "https://github.com/datamindedbe/checkup"
+Source = "https://github.com/datamindedbe/checkup"
+Issues = "https://github.com/datamindedbe/checkup/issues"
+
 [project.scripts]
 checkup = "checkup:main"
 

{checkup-0.5.0 → checkup-0.5.2}/src/checkup/cli/__init__.py

@@ -7,7 +7,7 @@ from typing import Annotated
 
 import typer
 
-from checkup.cli.commands import config, init, run, schema
+from checkup.cli.commands import config, init, plugins, run, schema
 
 app = typer.Typer(
     name="checkup",
@@ -36,3 +36,4 @@ app.command()(run)
 app.command()(init)
 app.command()(config)
 app.command()(schema)
+app.command()(plugins)

{checkup-0.5.0 → checkup-0.5.2}/src/checkup/cli/commands/__init__.py

@@ -4,12 +4,14 @@ CLI commands.
 
 from checkup.cli.commands.config import config
 from checkup.cli.commands.init import init
+from checkup.cli.commands.plugins import plugins
 from checkup.cli.commands.run import run
 from checkup.cli.commands.schema import schema
 
 __all__ = [
     "config",
     "init",
+    "plugins",
     "run",
     "schema",
 ]

checkup-0.5.2/src/checkup/cli/commands/plugins.py

@@ -0,0 +1,49 @@
+"""
+Plugins command. List installed checkup plugins.
+"""
+
+from rich.console import Console
+from rich.table import Table
+
+from checkup.registry import get_registry
+
+console = Console()
+
+
+def plugins() -> None:
+    """
+    List installed checkup plugins.
+    """
+
+    all_plugins = get_registry().list_plugins()
+    all_plugins.pop("checkup", None)
+
+    if not all_plugins:
+        console.print("[yellow]No checkup plugins installed[/yellow]")
+        return
+
+    kinds = [
+        ("Providers", "providers"),
+        ("Metrics", "metrics"),
+        ("Materializers", "materializers"),
+    ]
+    populated_kinds = [  # Hide columns that are empty
+        (header, attr)
+        for header, attr in kinds
+        if any(getattr(p, attr) for p in all_plugins.values())
+    ]
+
+    table = Table(title="Installed checkup plugins")
+    table.add_column("Plugin", style="bold", overflow="fold")
+    table.add_column("Version", overflow="fold")
+    for header, _ in populated_kinds:
+        table.add_column(header, overflow="fold")
+
+    for name, plugin in all_plugins.items():
+        table.add_row(
+            name,
+            plugin.version or "",
+            *("\n".join(getattr(plugin, attr)) for _, attr in populated_kinds),
+        )
+
+    console.print(table)

{checkup-0.5.0 → checkup-0.5.2}/src/checkup/cli/commands/run.py

@@ -40,6 +40,13 @@ def run(
         bool,
         typer.Option("--dry-run", help="Don't materialize, just print"),
     ] = False,
+    multiprocessing: Annotated[
+        bool,
+        typer.Option(
+            "--multiprocessing",
+            help="When disabled, run sequentially without subprocesses",
+        ),
+    ] = True,
     verbose: Annotated[
         bool,
         typer.Option("--verbose", "-v", help="Verbose output"),
@@ -55,4 +62,8 @@ def run(
     cfg = load_config(config_path=config)
     cfg = apply_cli_overrides(cfg, tag, provider, metric)
 
-    execute_checkup(cfg, materializer="console" if dry_run else materializer)
+    execute_checkup(
+        cfg,
+        materializer="console" if dry_run else materializer,
+        multiprocessing=multiprocessing,
+    )

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

@@ -23,13 +23,18 @@ logger = logging.getLogger(__name__)
 console = Console()
 
 
-def execute_checkup(config: CheckupConfig, materializer: str | None = None) -> None:
+def execute_checkup(
+    config: CheckupConfig,
+    materializer: str | None = None,
+    multiprocessing: bool = True,
+) -> None:
     """
     Execute checkup with the given configuration.
 
     Args:
         config: Loaded checkup configuration
         materializer: Override materializer type (e.g., "console")
+        multiprocessing: If False, run sequentially without subprocesses
     """
 
     registry = get_registry()
@@ -48,7 +53,12 @@ def execute_checkup(config: CheckupConfig, materializer: str | None = None) -> N
 
     console.print(f"[blue]Running {len(metrics)} metrics...[/blue]")
 
-    result = CheckHub().with_metrics(metrics).with_providers([providers]).measure()
+    result = (
+        CheckHub()
+        .with_metrics(metrics)
+        .with_providers([providers])
+        .measure(multiprocessing=multiprocessing)
+    )
 
     if result.errors:
         for _, error in result.errors:

{checkup-0.5.0 → checkup-0.5.2}/src/checkup/executor/metric_calculator.py

@@ -37,6 +37,15 @@ class MetricCalculator:
     Calculates metrics for a given context.
     """
 
+    def __init__(self, multiprocessing: bool = True) -> None:
+        """
+        Args:
+            multiprocessing: If False, metrics that request the PROCESS executor are run with the THREAD executor instead.
+                This avoids spawning subprocesses in environments that do not support it.
+        """
+
+        self._multiprocessing = multiprocessing
+
     def calculate(
         self,
         metrics: list[Metric],
@@ -193,6 +202,12 @@ class MetricCalculator:
         Execute a batch and record results.
         """
 
+        if not self._multiprocessing and executor_type is ExecutorType.PROCESS:
+            logger.debug(
+                "No subprocesses requested: running PROCESS batch with THREAD executor"
+            )
+            executor_type = ExecutorType.THREAD
+
         logger.debug(
             "Executing batch with %d metrics using %s executor",
             len(batch),

{checkup-0.5.0 → checkup-0.5.2}/src/checkup/hub.py

@@ -57,6 +57,7 @@ def _measure_single_provider_set(
     provider_set: list[Provider],
     metrics: list[Metric],
     execution_order: list[type[Metric]],
+    multiprocessing: bool = True,
 ) -> list[Measurement]:
     """Calculate all metrics for a single provider set.
 
@@ -66,6 +67,7 @@ def _measure_single_provider_set(
         provider_set: List of provider instances
         metrics: List of metric instances to calculate
         execution_order: Topologically sorted metric classes
+        multiprocessing: If False, run metric batches without subprocesses
 
     Returns:
         List of Measurements with tags merged
@@ -77,7 +79,7 @@ def _measure_single_provider_set(
     context, errors = ProviderExecutor().execute(provider_set)
     failed_providers = {type(e.provider): e for e in errors}
 
-    return MetricCalculator().calculate(
+    return MetricCalculator(multiprocessing=multiprocessing).calculate(
         metrics,
         execution_order,
         context,
@@ -133,11 +135,17 @@ class CheckHub:
     def measure(
         self,
         max_workers: int | None = None,
+        multiprocessing: bool = True,
     ) -> MeasurementResult:
-        """Execute the measurement pipeline.
+        """
+        Execute the measurement pipeline.
 
         Args:
             max_workers: Max parallel workers. None = use all CPUs.
+                Ignored when multiprocessing=False.
+            multiprocessing: If True, provider sets run in parallel via ProcessPoolExecutor.
+                If False, provider sets run sequentially and
+                metrics requesting the PROCESS executor fall back to threads.
 
         Returns:
             MeasurementResult containing all calculated measurements and errors
@@ -161,28 +169,46 @@ class CheckHub:
 
         all_measurements: list[Measurement] = []
         all_errors: list[tuple[list[Provider], Exception]] = []
-        workers = max_workers if max_workers is not None else os.cpu_count()
-
-        logger.debug("Executing with %d workers", workers)
-        with ProcessPoolExecutor(max_workers=workers) as executor:
-            future_to_provider_set = {
-                executor.submit(
-                    _measure_single_provider_set,
-                    provider_set=ps,
-                    metrics=self._metrics,
-                    execution_order=execution_order,
-                ): ps
-                for ps in provider_sets
-            }
-
-            for future in as_completed(future_to_provider_set):
-                ps = future_to_provider_set[future]
+
+        def _record(ps: list[Provider], e: Exception) -> None:
+            logger.error("Provider set failed: %s", e)
+            logger.debug("Provider set failure details:", exc_info=True)
+            all_errors.append((ps, e))
+
+        if multiprocessing:
+            workers = max_workers if max_workers is not None else os.cpu_count()
+            logger.debug("Executing with %d workers", workers)
+            with ProcessPoolExecutor(max_workers=workers) as executor:
+                future_to_provider_set = {
+                    executor.submit(
+                        _measure_single_provider_set,
+                        provider_set=ps,
+                        metrics=self._metrics,
+                        execution_order=execution_order,
+                    ): ps
+                    for ps in provider_sets
+                }
+
+                for future in as_completed(future_to_provider_set):
+                    ps = future_to_provider_set[future]
+                    try:
+                        all_measurements.extend(future.result())
+                    except Exception as e:
+                        _record(ps, e)
+        else:
+            logger.debug("Executing sequentially")
+            for ps in provider_sets:
                 try:
-                    all_measurements.extend(future.result())
+                    all_measurements.extend(
+                        _measure_single_provider_set(
+                            provider_set=ps,
+                            metrics=self._metrics,
+                            execution_order=execution_order,
+                            multiprocessing=False,
+                        )
+                    )
                 except Exception as e:
-                    logger.error("Provider set failed: %s", e)
-                    logger.debug("Provider set failure details:", exc_info=True)
-                    all_errors.append((ps, e))
+                    _record(ps, e)
 
         if all_errors:
             failed_contexts = []

{checkup-0.5.0 → checkup-0.5.2}/src/checkup/registry/__init__.py

@@ -3,11 +3,13 @@ Plugin registry for discovering providers, metrics, and materializers.
 """
 
 from checkup.registry.discovery import (
+    Plugin,
     PluginRegistry,
     get_registry,
 )
 
 __all__ = [
+    "Plugin",
     "PluginRegistry",
     "get_registry",
 ]

{checkup-0.5.0 → checkup-0.5.2}/src/checkup/registry/discovery.py

@@ -3,6 +3,7 @@ Plugin discovery via Python entry points.
 """
 
 import logging
+from dataclasses import dataclass, field
 from importlib.metadata import entry_points
 from typing import TYPE_CHECKING
 
@@ -13,6 +14,19 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+
+@dataclass
+class Plugin:
+    """
+    A distribution registering one or more checkup entry points.
+    """
+
+    version: str | None
+    providers: list[str] = field(default_factory=list)
+    metrics: list[str] = field(default_factory=list)
+    materializers: list[str] = field(default_factory=list)
+
+
 # Entry point group names
 PROVIDERS_GROUP = "checkup.providers"
 METRICS_GROUP = "checkup.metrics"
@@ -137,6 +151,37 @@ class PluginRegistry:
 
         return self._list_entry_point_names(MATERIALIZERS_GROUP)
 
+    def list_plugins(self) -> dict[str, Plugin]:
+        """
+        List installed plugins grouped by distribution.
+
+        Walks all checkup entry-point groups and groups them by the
+        distribution that registers them. Does not load plugin code.
+        """
+
+        groups = {
+            "providers": PROVIDERS_GROUP,
+            "metrics": METRICS_GROUP,
+            "materializers": MATERIALIZERS_GROUP,
+        }
+
+        plugins: dict[str, Plugin] = {}
+
+        for kind, group in groups.items():
+            for ep in entry_points(group=group):
+                dist = ep.dist
+                dist_name = dist.name if dist else "unknown"
+                dist_version = dist.version if dist else None
+
+                plugin = plugins.setdefault(dist_name, Plugin(version=dist_version))
+                getattr(plugin, kind).append(ep.name)
+
+        for plugin in plugins.values():
+            for kind in groups:
+                getattr(plugin, kind).sort()
+
+        return dict(sorted(plugins.items()))
+
     def list_compatible_metric_names(self, provider_names: list[str]) -> list[str]:
         """
         List metric names compatible with the given providers.