detectkit 0.7.0__tar.gz → 0.8.1__tar.gz

{detectkit-0.7.0/detectkit.egg-info → detectkit-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.7.0
+Version: 0.8.1
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT
@@ -84,7 +84,7 @@ Dynamic: license-file
 - **Project-level error alerts** — catch DB outages and pipeline crashes once per run
 - **Database agnostic** — ClickHouse, PostgreSQL, MySQL
 - **Idempotent** — resume from interruptions, no duplicate processing
-- **CLI** — `dtk init`, `dtk run --select`, `dtk unlock`, tag-based selectors
+- **CLI** — `dtk init`, `dtk run --select`, `dtk unlock`, `dtk clean`, tag-based selectors
 
 ## Installation
 
@@ -116,6 +116,9 @@ dtk run --select cpu_usage --from 2024-01-01
 
 # Clear a stuck lock left by a crashed run (e.g. DB restarted mid-run)
 dtk unlock --select cpu_usage
+
+# Prune data orphaned by config edits (dry-run; add --execute to apply)
+dtk clean --select cpu_usage
 ```
 
 ### Metric Configuration

{detectkit-0.7.0 → detectkit-0.8.1}/README.md

@@ -18,7 +18,7 @@
 - **Project-level error alerts** — catch DB outages and pipeline crashes once per run
 - **Database agnostic** — ClickHouse, PostgreSQL, MySQL
 - **Idempotent** — resume from interruptions, no duplicate processing
-- **CLI** — `dtk init`, `dtk run --select`, `dtk unlock`, tag-based selectors
+- **CLI** — `dtk init`, `dtk run --select`, `dtk unlock`, `dtk clean`, tag-based selectors
 
 ## Installation
 
@@ -50,6 +50,9 @@ dtk run --select cpu_usage --from 2024-01-01
 
 # Clear a stuck lock left by a crashed run (e.g. DB restarted mid-run)
 dtk unlock --select cpu_usage
+
+# Prune data orphaned by config edits (dry-run; add --execute to apply)
+dtk clean --select cpu_usage
 ```
 
 ### Metric Configuration

{detectkit-0.7.0 → detectkit-0.8.1}/detectkit/__init__.py

@@ -4,7 +4,7 @@ detectk - Anomaly Detection for Time-Series Metrics
 A Python library for data analysts and engineers to monitor metrics with automatic anomaly detection.
 """
 
-__version__ = "0.7.0"
+__version__ = "0.8.1"
 
 from detectkit.core.interval import Interval
 from detectkit.core.models import ColumnDefinition, TableModel

detectkit-0.8.1/detectkit/cli/commands/clean.py

@@ -0,0 +1,333 @@
+"""
+Implementation of 'dtk clean' command.
+
+Removes internal data that no longer matches the project's YAML configs —
+the rows left behind when an analyst edits metrics on production
+(TECHNICAL_SPEC.md §14.4 / init_plan.md "Сценарий Г"). Two modes:
+
+* ``--select`` (drift mode): for metrics that still exist, delete detection
+  results whose ``detector_id`` is no longer produced by the config (a
+  detector param/seasonality changed, or the detector was removed) and
+  alert-state rows whose ``alert_config_id`` is no longer produced (an
+  alerting block changed or was removed). Datapoints are NOT touched — they
+  are keyed only by (metric, timestamp) and never orphaned by a param edit;
+  use ``--full-refresh`` to reload those.
+
+* ``--orphaned-metrics`` (GC mode): delete ALL rows, across every internal
+  table, for metric names present in the database but no longer defined by
+  any YAML in the project (renamed or deleted metric).
+
+Both modes default to a dry-run that only reports what would be deleted;
+pass ``--execute`` to actually delete. Selector semantics match ``dtk run``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from detectkit.cli.commands.run import find_project_root, select_metrics
+from detectkit.config.metric_config import MetricConfig
+from detectkit.config.profile import ProfilesConfig
+from detectkit.config.validator import validate_project_metrics
+from detectkit.database.internal_tables import InternalTablesManager
+from detectkit.detectors.factory import DetectorFactory
+from detectkit.orchestration.task_manager._types import make_alert_config_id
+
+
+def run_clean(
+    select: str | None,
+    orphaned_metrics: bool,
+    execute: bool,
+    yes: bool,
+    profile: str | None,
+):
+    """Prune stale internal data that no longer matches the project configs.
+
+    Args:
+        select: Metric selector (drift mode) — same semantics as ``dtk run``.
+        orphaned_metrics: GC mode — purge metrics no longer present in the project.
+        execute: Actually delete (default: dry-run, only report).
+        yes: Skip the confirmation prompt in GC mode.
+        profile: Profile name to use (defaults to project's default_profile).
+    """
+    if bool(select) == bool(orphaned_metrics):
+        click.echo(
+            click.style(
+                "Error: choose exactly one of --select or --orphaned-metrics.",
+                fg="red",
+                bold=True,
+            )
+        )
+        return
+
+    project_root = find_project_root()
+    if not project_root:
+        click.echo(click.style("Error: Not in a detectkit project directory!", fg="red", bold=True))
+        click.echo("Run 'dtk init <project_name>' to create a new project.")
+        return
+
+    click.echo(f"Project root: {project_root}")
+
+    internal_manager = _create_internal_manager(project_root, profile)
+    if internal_manager is None:
+        return
+
+    if not execute:
+        click.echo(
+            click.style("DRY-RUN — nothing will be deleted. Use --execute to apply.", fg="cyan")
+        )
+    click.echo()
+
+    if select:
+        _clean_drift(internal_manager, select, project_root, execute)
+    else:
+        _clean_orphaned_metrics(internal_manager, project_root, execute, yes)
+
+
+# ── modes ──────────────────────────────────────────────────────────────────
+
+
+def _clean_drift(
+    internal_manager: InternalTablesManager,
+    select: str,
+    project_root: Path,
+    execute: bool,
+) -> None:
+    """Prune detector/alert data whose hash is no longer produced by the config."""
+    try:
+        metrics = select_metrics(select, project_root)
+    except ValueError as e:
+        click.echo(click.style(f"Error: {e}", fg="red", bold=True))
+        return
+
+    if not metrics:
+        click.echo(click.style(f"No metrics found matching selector: {select}", fg="yellow"))
+        return
+
+    click.echo(f"Found {len(metrics)} metric(s) to inspect")
+    click.echo()
+
+    total_det_groups = 0
+    total_alert_rows = 0
+
+    for _, config in metrics:
+        metric_name = config.name
+        try:
+            valid_detectors = _valid_detector_ids(config)
+            valid_alerts = _valid_alert_config_ids(config)
+            db_detectors = internal_manager.list_detector_ids(metric_name)
+            db_alerts = internal_manager.list_alert_config_ids(metric_name)
+        except Exception as e:
+            click.echo(click.style(f"  ✗ {metric_name}: error inspecting: {e}", fg="red"), err=True)
+            continue
+
+        orphan_detectors = {
+            det_id: count for det_id, count in db_detectors.items() if det_id not in valid_detectors
+        }
+        orphan_alerts = [a for a in db_alerts if a not in valid_alerts]
+
+        if not orphan_detectors and not orphan_alerts:
+            click.echo(f"  • {metric_name}: nothing stale")
+            continue
+
+        click.echo(click.style(f"  {metric_name}:", bold=True))
+
+        # An empty valid set means EVERY stored row is "orphaned" — usually a
+        # config mid-edit, not an intent to wipe the metric. Flag it loudly.
+        if orphan_detectors and not valid_detectors:
+            click.echo(
+                click.style(
+                    "    ⚠ config defines no detectors — ALL detections below would be removed",
+                    fg="yellow",
+                    bold=True,
+                )
+            )
+        if orphan_alerts and not valid_alerts:
+            click.echo(
+                click.style(
+                    "    ⚠ config defines no alerting — ALL alert states below would be removed",
+                    fg="yellow",
+                    bold=True,
+                )
+            )
+
+        for det_id, count in sorted(orphan_detectors.items()):
+            total_det_groups += 1
+            verb = "deleting" if execute else "would delete"
+            click.echo(f"    detector {det_id}: {verb} {count:,} detection row(s)")
+            if execute:
+                internal_manager.delete_detections(
+                    metric_name=metric_name, detector_id=det_id, mutations_sync=True
+                )
+
+        for alert_id in sorted(orphan_alerts):
+            total_alert_rows += 1
+            verb = "deleting" if execute else "would delete"
+            click.echo(f"    alert_config {alert_id}: {verb} stale alert state")
+            if execute:
+                internal_manager.delete_alert_state(metric_name, alert_id)
+
+    click.echo()
+    prefix = "Deleted" if execute else "Would delete"
+    click.echo(
+        click.style(
+            f"{prefix} {total_det_groups} orphaned detector group(s) "
+            f"and {total_alert_rows} orphaned alert-state row(s).",
+            fg="cyan",
+            bold=True,
+        )
+    )
+    if not execute and (total_det_groups or total_alert_rows):
+        click.echo("Re-run with --execute to apply.")
+
+
+def _clean_orphaned_metrics(
+    internal_manager: InternalTablesManager,
+    project_root: Path,
+    execute: bool,
+    yes: bool,
+) -> None:
+    """Purge all data for metrics present in the DB but absent from the project."""
+    try:
+        project_metrics = validate_project_metrics(project_root)
+        project_names = {config.name for _, config in project_metrics}
+    except FileNotFoundError:
+        # No metrics/ directory at all — every DB metric is technically orphaned.
+        project_names = set()
+    except ValueError as e:
+        # Duplicates / parse errors: we can't trust the project set, so refuse
+        # to delete anything rather than risk purging valid metrics.
+        click.echo(
+            click.style(
+                f"Error: cannot determine project metrics ({e}). "
+                "Fix the configs first; aborting to avoid deleting valid data.",
+                fg="red",
+                bold=True,
+            )
+        )
+        return
+
+    db_names = internal_manager.list_known_metric_names()
+    orphans = sorted(db_names - project_names)
+
+    if not orphans:
+        click.echo(click.style("No orphaned metrics — database matches the project.", fg="green"))
+        return
+
+    click.echo(f"Found {len(orphans)} metric(s) in the database with no YAML in the project:")
+    click.echo()
+    for name in orphans:
+        try:
+            counts = internal_manager.count_metric_rows(name)
+        except Exception as e:
+            click.echo(click.style(f"  ✗ {name}: error counting rows: {e}", fg="red"), err=True)
+            continue
+        total = sum(counts.values())
+        verb = "deleting" if execute else "would delete"
+        detail = ", ".join(f"{table}={count:,}" for table, count in counts.items() if count)
+        click.echo(
+            click.style(f"  {name}: {verb} {total:,} row(s)", bold=True)
+            + (f"  [{detail}]" if detail else "")
+        )
+
+    if not execute:
+        click.echo()
+        click.echo("Re-run with --execute to purge these metrics.")
+        return
+
+    # Guard: an empty project set means --execute would wipe EVERYTHING. Almost
+    # always a wrong directory / empty project, so demand explicit --yes.
+    if not project_names and not yes:
+        click.echo()
+        click.echo(
+            click.style(
+                "Refusing to purge: the project defines no metrics, so this would "
+                "delete ALL data. Re-run with --yes if that is really intended.",
+                fg="red",
+                bold=True,
+            )
+        )
+        return
+
+    if not yes:
+        click.echo()
+        if not click.confirm(
+            click.style(f"Permanently delete all data for {len(orphans)} metric(s)?", fg="yellow")
+        ):
+            click.echo("Aborted.")
+            return
+
+    purged = 0
+    for name in orphans:
+        try:
+            internal_manager.purge_metric(name)
+            purged += 1
+            click.echo(click.style(f"  ✓ {name}: purged", fg="green"))
+        except Exception as e:
+            click.echo(click.style(f"  ✗ {name}: error purging: {e}", fg="red"), err=True)
+
+    click.echo()
+    click.echo(
+        click.style(
+            f"Done. Purged {purged} of {len(orphans)} orphaned metric(s).", fg="cyan", bold=True
+        )
+    )
+
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+
+def _valid_detector_ids(config: MetricConfig) -> set[str]:
+    """Detector IDs the current config produces.
+
+    Mirrors the DETECT step exactly (DetectorFactory + the same seasonality
+    injection) so the computed ``detector_id`` matches what the pipeline
+    writes — anything in the DB not in this set is stale.
+    """
+    ids: set[str] = set()
+    for detector_config in config.detectors or []:
+        params = detector_config.get_algorithm_params()
+        seasonality_components = detector_config.get_seasonality_components()
+        if seasonality_components is not None:
+            params["seasonality_components"] = seasonality_components
+        detector = DetectorFactory.create_from_config(
+            {"type": detector_config.type, "params": params}
+        )
+        ids.add(detector.get_detector_id())
+    return ids
+
+
+def _valid_alert_config_ids(config: MetricConfig) -> set[str]:
+    """Alert-config IDs the current config produces (enabled or not).
+
+    Disabled blocks keep their hash, so a temporarily-disabled alert is NOT
+    treated as orphaned; only removed or functionally-changed blocks are.
+    """
+    return {make_alert_config_id(c) for c in (config.alerting or [])}
+
+
+def _create_internal_manager(
+    project_root: Path, profile: str | None
+) -> InternalTablesManager | None:
+    """Load profiles.yml and build an InternalTablesManager, or report and return None."""
+    profiles_path = project_root / "profiles.yml"
+    if not profiles_path.exists():
+        click.echo(click.style("Error: profiles.yml not found!", fg="red", bold=True))
+        click.echo(f"Expected at: {profiles_path}")
+        return None
+
+    try:
+        profiles_config = ProfilesConfig.from_yaml(profiles_path)
+    except Exception as e:
+        click.echo(click.style(f"Error loading profiles.yml: {e}", fg="red", bold=True))
+        return None
+
+    try:
+        db_manager = profiles_config.create_manager(profile)
+    except Exception as e:
+        click.echo(click.style(f"Error creating database manager: {e}", fg="red", bold=True))
+        return None
+
+    return InternalTablesManager(db_manager)

{detectkit-0.7.0 → detectkit-0.8.1}/detectkit/cli/commands/run.py

@@ -353,8 +353,21 @@ def select_metrics(selector: str, project_root: Path) -> list[tuple[Path, Metric
         metric_paths = find_metrics_by_tag(metrics_dir, tag)
     # Path pattern selector
     elif "*" in selector or "/" in selector:
-        pattern = selector if selector.startswith("metrics/") else f"metrics/{selector}"
-        metric_paths = list(project_root.glob(pattern))
+        if selector == "*":
+            # "all metrics" — search recursively so nested metrics are included
+            # (mirrors validate_project_metrics); a plain glob of "metrics/*"
+            # would only see the top level.
+            metric_paths = [p for sub in ("**/*.yml", "**/*.yaml") for p in metrics_dir.glob(sub)]
+        else:
+            pattern = selector if selector.startswith("metrics/") else f"metrics/{selector}"
+            # Keep only metric files: a bare glob also matches the `.gitkeep`
+            # stub created by `dtk init`, any other non-YAML files, and
+            # directories — all of which would crash the YAML parser.
+            metric_paths = [
+                p
+                for p in project_root.glob(pattern)
+                if p.is_file() and p.suffix in (".yml", ".yaml")
+            ]
     # Metric name selector
     else:
         # First try filename-based search in root (backward compatibility)

{detectkit-0.7.0 → detectkit-0.8.1}/detectkit/cli/main.py

@@ -218,5 +218,69 @@ def unlock(select: str, profile: str):
     run_unlock(select=select, profile=profile)
 
 
+@cli.command()
+@click.option(
+    "--select",
+    "-s",
+    help="Selector for metrics whose stale detector/alert data to prune (name, path, or tag)",
+)
+@click.option(
+    "--orphaned-metrics",
+    is_flag=True,
+    help="Purge all data for metrics no longer present in the project (renamed/deleted YAML)",
+)
+@click.option(
+    "--execute",
+    is_flag=True,
+    help="Actually delete (default: dry-run, only report what would be removed)",
+)
+@click.option(
+    "--yes",
+    "-y",
+    is_flag=True,
+    help="Skip the confirmation prompt (for --orphaned-metrics --execute)",
+)
+@click.option(
+    "--profile",
+    help="Profile to use (default: from project config)",
+)
+def clean(select: str, orphaned_metrics: bool, execute: bool, yes: bool, profile: str):
+    """
+    Remove internal data that no longer matches the project's YAML configs.
+
+    Over time, editing metrics on production leaves stale rows behind: changing
+    a detector parameter (or removing a detector) orphans its old results in
+    _dtk_detections, changing an alerting block orphans its state in
+    _dtk_alert_states, and renaming/deleting a metric orphans everything under
+    its old name. This command finds and removes that drift.
+
+    Both modes default to a dry-run; pass --execute to actually delete.
+    Selector semantics match `dtk run`.
+
+    Examples:
+        # Prune stale detector/alert data for one metric (dry-run)
+        dtk clean --select cpu_usage
+
+        # ...and actually delete it
+        dtk clean --select cpu_usage --execute
+
+        # Prune everything matching a tag
+        dtk clean --select "tag:critical" --execute
+
+        # Purge metrics that no longer exist in the project
+        dtk clean --orphaned-metrics
+        dtk clean --orphaned-metrics --execute
+    """
+    from detectkit.cli.commands.clean import run_clean
+
+    run_clean(
+        select=select,
+        orphaned_metrics=orphaned_metrics,
+        execute=execute,
+        yes=yes,
+        profile=profile,
+    )
+
+
 if __name__ == "__main__":
     cli()

{detectkit-0.7.0 → detectkit-0.8.1}/detectkit/database/internal_tables/_alert_states.py

@@ -113,6 +113,37 @@ class _AlertStatesMixin(_InternalTablesBase):
         }
         self._manager.insert_batch(full_table_name, insert_data, conflict_strategy="ignore")
 
+    def list_alert_config_ids(self, metric_name: str) -> list[str]:
+        """Return every ``alert_config_id`` with stored state for a metric.
+
+        Used by ``dtk clean`` to find alert-state rows left behind after an
+        alerting block was removed or its functional params changed (see
+        ``make_alert_config_id``).
+        """
+        full_table_name = self._manager.get_full_table_name(TABLE_ALERT_STATES, use_internal=True)
+        query = f"""
+        SELECT DISTINCT alert_config_id
+        FROM {full_table_name}
+        WHERE metric_name = %(metric_name)s
+        """
+        result = self._manager.execute_query(query, {"metric_name": metric_name})
+        return [row["alert_config_id"] for row in result if row.get("alert_config_id")]
+
+    def delete_alert_state(self, metric_name: str, alert_config_id: str) -> int:
+        """Delete the alert-state row for a single ``(metric, alert_config)``."""
+        full_table_name = self._manager.get_full_table_name(TABLE_ALERT_STATES, use_internal=True)
+        query = f"""
+        ALTER TABLE {full_table_name}
+        DELETE WHERE metric_name = %(metric_name)s
+          AND alert_config_id = %(alert_config_id)s
+        SETTINGS mutations_sync = 1
+        """
+        self._manager.execute_query(
+            query,
+            params={"metric_name": metric_name, "alert_config_id": alert_config_id},
+        )
+        return 0
+
     def get_last_alert_timestamp(
         self,
         metric_name: str,

{detectkit-0.7.0 → detectkit-0.8.1}/detectkit/database/internal_tables/_detections.py

@@ -62,8 +62,16 @@ class _DetectionsMixin(_InternalTablesBase):
         detector_id: str | None = None,
         from_timestamp: datetime | None = None,
         to_timestamp: datetime | None = None,
+        mutations_sync: bool = False,
     ) -> int:
-        """Delete detection rows for the supplied filter set."""
+        """Delete detection rows for the supplied filter set.
+
+        ``mutations_sync=True`` waits for the ClickHouse mutation to finish
+        before returning (``SETTINGS mutations_sync = 1``); the default keeps
+        the async behaviour used by the ``--full-refresh`` hot path. The
+        ``dtk clean`` command passes ``True`` so a follow-up dry-run reflects
+        the deletion immediately.
+        """
         full_table_name = self._manager.get_full_table_name(TABLE_DETECTIONS, use_internal=True)
 
         where_parts = ["metric_name = %(metric_name)s"]
@@ -79,9 +87,27 @@ class _DetectionsMixin(_InternalTablesBase):
             params["to_timestamp"] = to_timestamp
 
         query = f"ALTER TABLE {full_table_name} DELETE WHERE {' AND '.join(where_parts)}"
+        if mutations_sync:
+            query += " SETTINGS mutations_sync = 1"
         self._manager.execute_query(query, params=params)
         return 0
 
+    def list_detector_ids(self, metric_name: str) -> dict[str, int]:
+        """Return ``{detector_id: row_count}`` for every detector stored for a metric.
+
+        Used by ``dtk clean`` to spot detector results left behind after a
+        config change altered the detector hash (see ``get_detector_id``).
+        """
+        full_table_name = self._manager.get_full_table_name(TABLE_DETECTIONS, use_internal=True)
+        query = f"""
+        SELECT detector_id, count() AS cnt
+        FROM {full_table_name}
+        WHERE metric_name = %(metric_name)s
+        GROUP BY detector_id
+        """
+        result = self._manager.execute_query(query, {"metric_name": metric_name})
+        return {row["detector_id"]: int(row["cnt"]) for row in result if row.get("detector_id")}
+
     def get_recent_detections(
         self,
         metric_name: str,

detectkit-0.8.1/detectkit/database/internal_tables/_maintenance.py

@@ -0,0 +1,70 @@
+"""Maintenance mixin: cross-table cleanup helpers for ``dtk clean``.
+
+These support pruning data left behind when an analyst edits metric configs
+on production — most importantly removing all rows for a metric whose YAML no
+longer exists in the project (TECHNICAL_SPEC.md §14.4 / init_plan.md
+"Сценарий Г"). They are used only by the ``dtk clean`` CLI command, never by
+the run pipeline.
+"""
+
+from __future__ import annotations
+
+from detectkit.database.internal_tables._base import _InternalTablesBase
+from detectkit.database.tables import (
+    TABLE_ALERT_STATES,
+    TABLE_DATAPOINTS,
+    TABLE_DETECTIONS,
+    TABLE_METRICS,
+    TABLE_TASKS,
+)
+
+# Every internal table is keyed by ``metric_name``, so a metric removed from
+# the project (renamed or deleted YAML) leaves orphaned rows in all of them.
+METRIC_KEYED_TABLES: tuple[str, ...] = (
+    TABLE_DATAPOINTS,
+    TABLE_DETECTIONS,
+    TABLE_TASKS,
+    TABLE_ALERT_STATES,
+    TABLE_METRICS,
+)
+
+
+class _MaintenanceMixin(_InternalTablesBase):
+    def list_known_metric_names(self) -> set[str]:
+        """Return every ``metric_name`` that has rows in any internal table.
+
+        Unions ``SELECT DISTINCT metric_name`` across all metric-keyed tables
+        so a metric is reported even if it only ever loaded datapoints (and
+        thus never wrote an alert state, etc.).
+        """
+        names: set[str] = set()
+        for table in METRIC_KEYED_TABLES:
+            full_table_name = self._manager.get_full_table_name(table, use_internal=True)
+            query = f"SELECT DISTINCT metric_name FROM {full_table_name}"
+            result = self._manager.execute_query(query)
+            names.update(row["metric_name"] for row in result if row.get("metric_name"))
+        return names
+
+    def count_metric_rows(self, metric_name: str) -> dict[str, int]:
+        """Return per-table row counts for *metric_name* (for dry-run reports)."""
+        counts: dict[str, int] = {}
+        for table in METRIC_KEYED_TABLES:
+            full_table_name = self._manager.get_full_table_name(table, use_internal=True)
+            query = f"SELECT count() AS cnt FROM {full_table_name} WHERE metric_name = %(m)s"
+            result = self._manager.execute_query(query, {"m": metric_name})
+            counts[table] = int(result[0]["cnt"]) if result else 0
+        return counts
+
+    def purge_metric(self, metric_name: str) -> None:
+        """Delete every row for *metric_name* across all internal tables.
+
+        Each delete waits for its mutation (``SETTINGS mutations_sync = 1``)
+        so the purge is fully applied when this returns.
+        """
+        for table in METRIC_KEYED_TABLES:
+            full_table_name = self._manager.get_full_table_name(table, use_internal=True)
+            query = (
+                f"ALTER TABLE {full_table_name} DELETE WHERE metric_name = %(m)s "
+                f"SETTINGS mutations_sync = 1"
+            )
+            self._manager.execute_query(query, {"m": metric_name})

{detectkit-0.7.0 → detectkit-0.8.1}/detectkit/database/internal_tables/manager.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from detectkit.database.internal_tables._alert_states import _AlertStatesMixin
 from detectkit.database.internal_tables._datapoints import _DatapointsMixin
 from detectkit.database.internal_tables._detections import _DetectionsMixin
+from detectkit.database.internal_tables._maintenance import _MaintenanceMixin
 from detectkit.database.internal_tables._metrics import _MetricsMixin
 from detectkit.database.internal_tables._schema import _SchemaMixin
 from detectkit.database.internal_tables._tasks import _TasksMixin
@@ -17,6 +18,7 @@ class InternalTablesManager(
     _TasksMixin,
     _MetricsMixin,
     _AlertStatesMixin,
+    _MaintenanceMixin,
 ):
     """High-level façade over a :class:`BaseDatabaseManager` for ``_dtk_*`` tables.
 

{detectkit-0.7.0 → detectkit-0.8.1/detectkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.7.0
+Version: 0.8.1
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT
@@ -84,7 +84,7 @@ Dynamic: license-file
 - **Project-level error alerts** — catch DB outages and pipeline crashes once per run
 - **Database agnostic** — ClickHouse, PostgreSQL, MySQL
 - **Idempotent** — resume from interruptions, no duplicate processing
-- **CLI** — `dtk init`, `dtk run --select`, `dtk unlock`, tag-based selectors
+- **CLI** — `dtk init`, `dtk run --select`, `dtk unlock`, `dtk clean`, tag-based selectors
 
 ## Installation
 
@@ -116,6 +116,9 @@ dtk run --select cpu_usage --from 2024-01-01
 
 # Clear a stuck lock left by a crashed run (e.g. DB restarted mid-run)
 dtk unlock --select cpu_usage
+
+# Prune data orphaned by config edits (dry-run; add --execute to apply)
+dtk clean --select cpu_usage
 ```
 
 ### Metric Configuration

{detectkit-0.7.0 → detectkit-0.8.1}/detectkit.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ detectkit/alerting/orchestrator/orchestrator.py
 detectkit/cli/__init__.py
 detectkit/cli/main.py
 detectkit/cli/commands/__init__.py
+detectkit/cli/commands/clean.py
 detectkit/cli/commands/init.py
 detectkit/cli/commands/run.py
 detectkit/cli/commands/test_alert.py
@@ -52,6 +53,7 @@ detectkit/database/internal_tables/_alert_states.py
 detectkit/database/internal_tables/_base.py
 detectkit/database/internal_tables/_datapoints.py
 detectkit/database/internal_tables/_detections.py
+detectkit/database/internal_tables/_maintenance.py
 detectkit/database/internal_tables/_metrics.py
 detectkit/database/internal_tables/_schema.py
 detectkit/database/internal_tables/_tasks.py