aver-drift 0.1.0__py3-none-any.whl

aver_drift/__init__.py

@@ -0,0 +1,22 @@
+"""Aver drift: snapshot diff, rule-derived severity and the policy engine (F-40–F-42)."""
+
+from .classify import DEFAULT_POLICY, Classification, Fired, MetricDelta, classify, metric_deltas, semver_bump
+from .diff import Change, diff_snapshots, unpinned
+from .policy import HistoricalEvent, PolicyError, simulate, validate_policy
+
+__all__ = [
+    "DEFAULT_POLICY",
+    "Change",
+    "Classification",
+    "Fired",
+    "HistoricalEvent",
+    "MetricDelta",
+    "PolicyError",
+    "classify",
+    "diff_snapshots",
+    "metric_deltas",
+    "semver_bump",
+    "simulate",
+    "unpinned",
+    "validate_policy",
+]

aver_drift/classify.py

@@ -0,0 +1,441 @@
+"""Rule-derived drift severity (F-41, F-42, PRD §14.2–14.4, Appendix C, ADR-011; invariant 9).
+
+No model decides severity. Every classification lists each rule that fired,
+with its source and reason, so a laboratory can defend it to an inspector.
+
+    1. diff baseline snapshot vs new snapshot
+    2. class rules, semver rules, digest-only rules per change
+    3. re-run needed if anything is above `documentation`
+    4. metric deltas (pp) from the re-run vs baseline
+    5. policy rules on deltas and dependency classes
+    6. final severity = max(dependency-derived, metric-derived)
+    7. rationale = every rule that fired
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any
+
+from .diff import Change
+
+SEVERITIES = ("informational", "documentation", "review_required", "revalidation_required", "critical")
+RANK = {s: i for i, s in enumerate(SEVERITIES)}
+
+# Parameters that cannot change results. Labs extend this list in their policy.
+DEFAULT_SAFE_PARAMS = frozenset(
+    {"publish_dir_mode", "max_multiqc_email_size", "multiqc_title", "email", "validate_params"}
+)
+
+
+@dataclass(frozen=True)
+class Fired:
+    rule_id: str
+    source: str  # class_rule | semver_rule | digest_rule | policy | integrity
+    severity: str
+    reason: str
+    change: Mapping[str, Any] | None = None
+
+    def as_dict(self) -> dict[str, Any]:
+        d = {"rule_id": self.rule_id, "source": self.source, "severity": self.severity, "reason": self.reason}
+        if self.change is not None:
+            d["change"] = dict(self.change)
+        return d
+
+
+@dataclass(frozen=True)
+class MetricDelta:
+    variant_class: str  # SNP | INDEL
+    metric: str  # recall | precision | f_measure
+    stratum: str | None
+    baseline: float
+    current: float
+
+    @property
+    def delta_pp(self) -> float:
+        return round((self.current - self.baseline) * 100, 6)
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "variant_class": self.variant_class,
+            "metric": self.metric,
+            "stratum": self.stratum,
+            "baseline": self.baseline,
+            "current": self.current,
+            "delta_pp": self.delta_pp,
+        }
+
+
+@dataclass(frozen=True)
+class Classification:
+    severity: str
+    rationale: tuple[Fired, ...]
+    rerun_required: bool
+    blocks_baseline: bool
+    changes: tuple[Change, ...] = ()
+    deltas: tuple[MetricDelta, ...] = field(default_factory=tuple)
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "severity": self.severity,
+            "rerun_required": self.rerun_required,
+            "blocks_baseline": self.blocks_baseline,
+            "rationale": [f.as_dict() for f in self.rationale],
+            "changes": [c.as_dict() for c in self.changes],
+            "metric_deltas": [d.as_dict() for d in self.deltas],
+        }
+
+
+_SEMVER = re.compile(r"^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?")
+
+
+def semver_bump(old: str | None, new: str | None) -> str | None:
+    """'major' | 'minor' | 'patch' | 'other' for two version strings, None if equal."""
+    if old == new:
+        return None
+    mo, mn = _SEMVER.match(old or ""), _SEMVER.match(new or "")
+    if not (mo and mn):
+        return "other"
+    a = [int(x) if x else 0 for x in mo.groups()]
+    b = [int(x) if x else 0 for x in mn.groups()]
+    if a[0] != b[0]:
+        return "major"
+    if a[1] != b[1]:
+        return "minor"
+    if a[2] != b[2]:
+        return "patch"
+    return "other"  # e.g. build suffix only
+
+
+def classify_changes(
+    changes: Sequence[Change], *, clinical: bool, safe_params: Iterable[str] = DEFAULT_SAFE_PARAMS
+) -> list[Fired]:
+    """Steps 2a–2c: dependency-derived rules (Appendix C)."""
+    safe = set(safe_params)
+    fired: list[Fired] = []
+    tool_version_changed_procs = {p for c in changes if c.kind == "tool" and c.field == "version" for p in c.processes}
+    conda_envs_fired: set[str] = set()
+    for c in changes:
+        ch = c.as_dict()
+        if c.kind == "reference_genome":
+            fired.append(
+                Fired(
+                    "reference-genome-change",
+                    "class_rule",
+                    "revalidation_required",
+                    f"Reference genome {c.name} changed ({c.field}: {c.old} → {c.new}).",
+                    ch,
+                )
+            )
+        elif c.kind == "annotation_db":
+            fired.append(
+                Fired(
+                    "annotation-db-release",
+                    "class_rule",
+                    "review_required",
+                    f"Annotation database {c.name} changed ({c.old} → {c.new}).",
+                    ch,
+                )
+            )
+        elif c.kind == "tool" and c.field == "version":
+            bump = semver_bump(c.old, c.new)
+            weight = "elevated weight" if bump in ("major", "minor") else "standard weight"
+            fired.append(
+                Fired(
+                    f"semver-{bump}",
+                    "semver_rule",
+                    "review_required",
+                    f"{c.name} {bump} version change {c.old} → {c.new} ({weight}); benchmark re-run required.",
+                    ch,
+                )
+            )
+        elif c.kind == "container" and c.field == "digest":
+            if set(c.processes) & tool_version_changed_procs or c.old is None or c.new is None:
+                continue  # covered by the tool rule, or by the pinned rule below
+            fired.append(
+                Fired(
+                    "container-rebuilt-same-versions",
+                    "digest_rule",
+                    "documentation",
+                    f"{c.name} digest changed with identical tool versions; results provably unchanged "
+                    "only if tool versions match, so the manifest is updated without a re-run.",
+                    ch,
+                )
+            )
+        elif c.kind == "container" and c.field == "version":
+            if not set(c.processes) & tool_version_changed_procs:
+                fired.append(
+                    Fired(
+                        "container-tag-change",
+                        "class_rule",
+                        "review_required",
+                        f"{c.name} tag changed {c.old} → {c.new} without a readable tool version.",
+                        ch,
+                    )
+                )
+        elif c.kind == "conda_env" and c.field in ("digest", "version"):
+            if c.old is None or c.new is None:
+                continue  # env file became (un)readable; the unpinned rules cover it
+            if set(c.processes) & tool_version_changed_procs:
+                continue  # an exactly-declared tool version moved; the semver rule covers it
+            if c.name in conda_envs_fired:
+                continue  # one firing per environment when digest and wrapper release both changed
+            conda_envs_fired.add(c.name)
+            what = "wrapper release" if c.field == "version" else "file"
+            detail = f" {c.old} → {c.new}" if c.field == "version" else ""
+            if clinical:
+                fired.append(
+                    Fired(
+                        "conda-env-changed-clinical",
+                        "class_rule",
+                        "review_required",
+                        f"Conda environment {c.name} {what} changed{detail} with no exactly-declared tool "
+                        "version change; what conda installs may move, so the benchmark re-runs (ADR-011).",
+                        ch,
+                    )
+                )
+            else:
+                fired.append(
+                    Fired(
+                        "conda-env-changed",
+                        "class_rule",
+                        "documentation",
+                        f"Conda environment {c.name} {what} changed{detail} with no exactly-declared tool "
+                        "version change; recorded without a re-run (ADR-011; pipeline not marked clinical).",
+                        ch,
+                    )
+                )
+        elif c.kind == "engine" and c.field == "version":
+            fired.append(
+                Fired(
+                    "engine-version-change",
+                    "class_rule",
+                    "review_required",
+                    f"Workflow engine {c.name} changed {c.old} → {c.new}.",
+                    ch,
+                )
+            )
+        elif c.kind == "parameter":
+            if c.name in safe:
+                fired.append(
+                    Fired(
+                        "parameter-declared-safe",
+                        "class_rule",
+                        "informational",
+                        f"Parameter {c.name} changed; it is on the declared-safe list.",
+                        ch,
+                    )
+                )
+            else:
+                fired.append(
+                    Fired(
+                        "parameter-change",
+                        "class_rule",
+                        "review_required",
+                        f"Parameter {c.name} changed {c.old} → {c.new} (not on the declared-safe list).",
+                        ch,
+                    )
+                )
+        elif c.field in ("added", "removed"):
+            fired.append(
+                Fired(
+                    f"dependency-{c.field}",
+                    "class_rule",
+                    "review_required",
+                    f"{c.kind} {c.name} {c.field} ({c.old or c.new}).",
+                    ch,
+                )
+            )
+    return fired
+
+
+def _unpinned_rule(kind: str, name: str, clinical: bool, change: Mapping[str, Any] | None) -> Fired:
+    if clinical:
+        return Fired(
+            "unpinned-dependency-clinical",
+            "class_rule",
+            "critical",
+            f"{kind} {name} is not pinned to an immutable version in a pipeline marked clinical.",
+            change,
+        )
+    return Fired(
+        "unpinned-dependency",
+        "class_rule",
+        "informational",
+        f"{kind} {name} is not pinned to an immutable version (finding; pipeline not marked clinical).",
+        change,
+    )
+
+
+def unpinned_rules(unpinned_deps: Iterable[Mapping[str, Any]], *, clinical: bool) -> list[Fired]:
+    """F-20 AC-4: unpinned dependencies present in the new snapshot."""
+    return [_unpinned_rule(d["kind"], d["name"], clinical, None) for d in unpinned_deps]
+
+
+def evaluate_policy(
+    rules: Sequence[Mapping[str, Any]],
+    *,
+    deltas: Sequence[MetricDelta],
+    changes: Sequence[Change],
+    clinical: bool,
+    unpinned_count: int,
+    policy_version: int | None = None,
+) -> list[Fired]:
+    """Step 5: policy rules in the §14.4 schema."""
+    fired: list[Fired] = []
+    tag = f" (policy v{policy_version})" if policy_version else ""
+    for r in rules:
+        when, cond, sev = r.get("when", {}), r.get("condition", {}), r["severity"]
+        if sev not in RANK:
+            raise ValueError(f"rule {r.get('id')}: unknown severity {sev!r}")
+        if "metric" in when:
+            for d in deltas:
+                if d.metric != when["metric"] or d.variant_class != when.get("variant_class", d.variant_class):
+                    continue
+                if "stratum" in when and d.stratum != when["stratum"]:
+                    continue
+                if "stratum" not in when and d.stratum is not None:
+                    continue
+                limit = cond.get("delta_pp_below")
+                if limit is not None and d.delta_pp < float(limit):
+                    fired.append(
+                        Fired(
+                            r["id"],
+                            "policy",
+                            sev,
+                            f"{_label(d)} delta {_pp(d.delta_pp)} is below the {_pp(float(limit))} threshold{tag}.",
+                            d.as_dict(),
+                        )
+                    )
+        elif "dependency_kind" in when:
+            hit = [c for c in changes if c.kind == when["dependency_kind"]]
+            if hit and cond.get("changed", True):
+                fired.append(
+                    Fired(
+                        r["id"],
+                        "policy",
+                        sev,
+                        f"Any change to {when['dependency_kind']} triggers {sev}{tag}.",
+                        hit[0].as_dict(),
+                    )
+                )
+        elif when.get("dependency_pinned") is False:
+            applies = when.get("pipeline_clinical") is None or when.get("pipeline_clinical") == clinical
+            if applies and unpinned_count > 0 and cond.get("present", True):
+                fired.append(Fired(r["id"], "policy", sev, f"{unpinned_count} unpinned dependencies present{tag}."))
+    return fired
+
+
+def _label(d: MetricDelta) -> str:
+    cls = "SNV" if d.variant_class == "SNP" else d.variant_class
+    metric = {"f_measure": "F1"}.get(d.metric, d.metric)
+    return f"{cls} {metric}" + (f" ({d.stratum})" if d.stratum else "")
+
+
+def _pp(v: float) -> str:
+    sign = "−" if v < 0 else "+"
+    return f"{sign}{abs(v):.3f} pp"
+
+
+def classify(
+    changes: Sequence[Change],
+    *,
+    clinical: bool,
+    deltas: Sequence[MetricDelta] = (),
+    policy_rules: Sequence[Mapping[str, Any]] = (),
+    policy_version: int | None = None,
+    unpinned_deps: Sequence[Mapping[str, Any]] = (),
+    safe_params: Iterable[str] = DEFAULT_SAFE_PARAMS,
+    integrity: Sequence[Fired] = (),
+) -> Classification:
+    """Final severity = max(dependency-derived, metric-derived); rationale lists every rule."""
+    fired = [*integrity, *classify_changes(changes, clinical=clinical, safe_params=safe_params)]
+    fired += unpinned_rules(unpinned_deps, clinical=clinical)
+    fired += evaluate_policy(
+        policy_rules,
+        deltas=deltas,
+        changes=changes,
+        clinical=clinical,
+        unpinned_count=len(unpinned_deps),
+        policy_version=policy_version,
+    )
+    if not fired and changes:
+        fired.append(Fired("no-rule-matched", "class_rule", "informational", "Changes detected; no rule raised them."))
+    if not changes and not fired:
+        fired.append(
+            Fired(
+                "no-dependency-change",
+                "class_rule",
+                "informational",
+                "Commit changed but the dependency snapshot is identical (e.g. documentation only).",
+            )
+        )
+    fired.sort(key=lambda f: (-RANK[f.severity], f.source, f.rule_id))
+    severity = fired[0].severity
+    dep_severity = max((RANK[f.severity] for f in fired if f.source != "policy"), default=0)
+    return Classification(
+        severity=severity,
+        rationale=tuple(fired),
+        rerun_required=dep_severity > RANK["documentation"] and not deltas,
+        blocks_baseline=RANK[severity] >= RANK["revalidation_required"],
+        changes=tuple(changes),
+        deltas=tuple(deltas),
+    )
+
+
+def metric_deltas(baseline: Sequence[Mapping[str, Any]], current: Sequence[Mapping[str, Any]]) -> list[MetricDelta]:
+    """Per class and stratum deltas from two sets of PASS metric rows."""
+
+    def key(m):
+        return (m["variant_class"], m.get("stratification"))
+
+    base = {key(m): m for m in baseline if m.get("filter", "PASS") == "PASS"}
+    out: list[MetricDelta] = []
+    for m in current:
+        if m.get("filter", "PASS") != "PASS" or key(m) not in base:
+            continue
+        b = base[key(m)]
+        for metric in ("recall", "precision", "f_measure"):
+            if m.get(metric) is not None and b.get(metric) is not None:
+                out.append(MetricDelta(m["variant_class"], metric, m.get("stratification"), b[metric], m[metric]))
+    return sorted(out, key=lambda d: (d.variant_class, d.stratum or "", d.metric))
+
+
+DEFAULT_POLICY = {
+    "version": 1,
+    "rules": [
+        {
+            "id": "snv-recall-guard",
+            "when": {"metric": "recall", "variant_class": "SNP", "stratum": None},
+            "condition": {"delta_pp_below": -0.5},
+            "severity": "revalidation_required",
+        },
+        {
+            "id": "indel-recall-guard",
+            "when": {"metric": "recall", "variant_class": "INDEL"},
+            "condition": {"delta_pp_below": -1.0},
+            "severity": "revalidation_required",
+        },
+        {
+            "id": "indel-precision-guard",
+            "when": {"metric": "precision", "variant_class": "INDEL"},
+            "condition": {"delta_pp_below": -1.0},
+            "severity": "revalidation_required",
+        },
+        {
+            "id": "reference-genome-change",
+            "when": {"dependency_kind": "reference_genome"},
+            "condition": {"changed": True},
+            "severity": "revalidation_required",
+        },
+        {
+            "id": "unpinned-in-clinical",
+            "when": {"pipeline_clinical": True, "dependency_pinned": False},
+            "condition": {"present": True},
+            "severity": "critical",
+        },
+    ],
+}
+"""PRD §14.4 example policy, used when a lab has not configured its own."""

aver_drift/diff.py

@@ -0,0 +1,114 @@
+"""Structured diff between two dependency snapshots (F-21, F-40 AC-3).
+
+Every change names the field, the old value, the new value and the workflow
+processes it affects. Output order is deterministic.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any
+
+ChangeField = str  # 'version' | 'digest' | 'added' | 'removed' | 'pinned' | 'value'
+
+
+@dataclass(frozen=True)
+class Change:
+    kind: str
+    name: str
+    field: ChangeField
+    old: str | None
+    new: str | None
+    processes: tuple[str, ...] = ()
+    meta: Mapping[str, Any] = field(default_factory=dict)
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "name": self.name,
+            "field": self.field,
+            "from": self.old,
+            "to": self.new,
+            "processes": list(self.processes),
+        }
+
+
+def _deps(snapshot: Mapping[str, Any] | Any) -> list[Mapping[str, Any]]:
+    if hasattr(snapshot, "model_dump"):
+        snapshot = snapshot.model_dump(mode="json")
+    return list(snapshot["dependencies"])
+
+
+def _key(d: Mapping[str, Any]) -> tuple[str, str, tuple[str, ...]]:
+    # A container repository can be used at several tags by different processes,
+    # so containers are keyed by the processes that use them as well.
+    procs = tuple(d.get("process_names") or ()) if d["kind"] in ("container", "tool") else ()
+    return (d["kind"], d["name"], procs)
+
+
+def _pair(old: Sequence[Mapping[str, Any]], new: Sequence[Mapping[str, Any]]):
+    """Match dependencies by (kind, name, processes), then by (kind, name) for the rest."""
+    old_by = {_key(d): d for d in old}
+    new_by = {_key(d): d for d in new}
+    pairs = [(old_by[k], new_by[k]) for k in sorted(old_by.keys() & new_by.keys())]
+    rest_old = [old_by[k] for k in sorted(old_by.keys() - new_by.keys())]
+    rest_new = [new_by[k] for k in sorted(new_by.keys() - old_by.keys())]
+    # second pass: same kind and name, processes changed
+    unmatched_new = list(rest_new)
+    still_old = []
+    for o in rest_old:
+        m = next((n for n in unmatched_new if n["kind"] == o["kind"] and n["name"] == o["name"]), None)
+        if m is None:
+            still_old.append(o)
+        else:
+            unmatched_new.remove(m)
+            pairs.append((o, m))
+    return pairs, still_old, unmatched_new
+
+
+def diff_snapshots(old: Any, new: Any) -> list[Change]:
+    """Changes from `old` to `new`, sorted by (kind, name, field)."""
+    pairs, removed, added = _pair(_deps(old), _deps(new))
+    changes: list[Change] = []
+    for o, n in pairs:
+        procs = tuple(sorted(set(o.get("process_names") or ()) | set(n.get("process_names") or ())))
+        if o["kind"] == "parameter":
+            if o.get("version") != n.get("version"):
+                changes.append(Change("parameter", o["name"], "value", o.get("version"), n.get("version")))
+            continue
+        if o.get("version") != n.get("version"):
+            changes.append(Change(o["kind"], o["name"], "version", o.get("version"), n.get("version"), procs))
+        if o.get("digest") != n.get("digest"):
+            changes.append(Change(o["kind"], o["name"], "digest", o.get("digest"), n.get("digest"), procs))
+        if bool(o.get("is_pinned", True)) != bool(n.get("is_pinned", True)):
+            changes.append(
+                Change(
+                    o["kind"],
+                    o["name"],
+                    "pinned",
+                    str(o.get("is_pinned")).lower(),
+                    str(n.get("is_pinned")).lower(),
+                    procs,
+                )
+            )
+    for d in removed:
+        changes.append(Change(d["kind"], d["name"], "removed", _label(d), None, tuple(d.get("process_names") or ())))
+    for d in added:
+        changes.append(Change(d["kind"], d["name"], "added", None, _label(d), tuple(d.get("process_names") or ())))
+    return sorted(changes, key=lambda c: (c.kind, c.name, c.field, c.processes))
+
+
+def _label(d: Mapping[str, Any]) -> str | None:
+    return d.get("version") or d.get("digest")
+
+
+def unpinned(snapshot: Any) -> list[Mapping[str, Any]]:
+    return [d for d in _deps(snapshot) if not d.get("is_pinned", True)]
+
+
+def summarise(changes: Iterable[Change]) -> dict[str, int]:
+    out: dict[str, int] = {}
+    for c in changes:
+        out[c.kind] = out.get(c.kind, 0) + 1
+    return dict(sorted(out.items()))

aver_drift/policy.py

@@ -0,0 +1,91 @@
+"""Revalidation policy engine: validation and simulation (F-42, PRD §14.4).
+
+`simulate` answers "what would this threshold have flagged over our history?"
+before a lab adopts it (AC-1..3). Policies are data: versioned, audited rows.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from .classify import RANK, MetricDelta, evaluate_policy
+from .diff import Change
+
+KNOWN_WHEN = {"metric", "variant_class", "stratum", "dependency_kind", "pipeline_clinical", "dependency_pinned"}
+KNOWN_COND = {"delta_pp_below", "changed", "present"}
+
+
+class PolicyError(ValueError):
+    pass
+
+
+def validate_policy(policy: Mapping[str, Any]) -> None:
+    """Reject rules the engine would silently ignore."""
+    rules = policy.get("rules")
+    if not isinstance(policy.get("version"), int) or not isinstance(rules, list) or not rules:
+        raise PolicyError("policy needs an integer version and a non-empty rules list")
+    ids = [r.get("id") for r in rules]
+    if len(set(ids)) != len(ids) or not all(isinstance(i, str) and i for i in ids):
+        raise PolicyError("every rule needs a unique, non-empty id")
+    for r in rules:
+        if r.get("severity") not in RANK:
+            raise PolicyError(f"{r['id']}: severity must be one of {', '.join(RANK)}")
+        unknown = (set(r.get("when", {})) - KNOWN_WHEN) | (set(r.get("condition", {})) - KNOWN_COND)
+        if unknown:
+            raise PolicyError(f"{r['id']}: unknown keys {', '.join(sorted(unknown))}")
+        if "metric" in r.get("when", {}):
+            if r["when"]["metric"] not in ("recall", "precision", "f_measure"):
+                raise PolicyError(f"{r['id']}: metric must be recall, precision or f_measure")
+            if not isinstance(r.get("condition", {}).get("delta_pp_below"), (int, float)):
+                raise PolicyError(f"{r['id']}: metric rules need a numeric condition.delta_pp_below")
+
+
+@dataclass(frozen=True)
+class HistoricalEvent:
+    event_id: str
+    pipeline: str
+    title: str
+    detected_at: str
+    clinical: bool
+    changes: tuple[Change, ...]
+    deltas: tuple[MetricDelta, ...]
+    unpinned_count: int = 0
+
+
+def simulate(policy: Mapping[str, Any], history: Sequence[HistoricalEvent]) -> dict[str, Any]:
+    """Evaluate `policy` against past events; deterministic output."""
+    validate_policy(policy)
+    flagged = []
+    for e in sorted(history, key=lambda e: (e.detected_at, e.event_id)):
+        fired = evaluate_policy(
+            policy["rules"],
+            deltas=e.deltas,
+            changes=e.changes,
+            clinical=e.clinical,
+            unpinned_count=e.unpinned_count,
+            policy_version=policy["version"],
+        )
+        if fired:
+            worst = max(fired, key=lambda f: RANK[f.severity])
+            snv = next(
+                (
+                    d.delta_pp
+                    for d in e.deltas
+                    if d.variant_class == "SNP" and d.metric == "recall" and d.stratum is None
+                ),
+                None,
+            )
+            flagged.append(
+                {
+                    "event_id": e.event_id,
+                    "pipeline": e.pipeline,
+                    "title": e.title,
+                    "detected_at": e.detected_at,
+                    "severity": worst.severity,
+                    "rules": sorted({f.rule_id for f in fired}),
+                    "snv_recall_delta_pp": snv,
+                }
+            )
+    return {"policy_version": policy["version"], "evaluated": len(history), "flagged": flagged}

aver_drift-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: aver-drift
+Version: 0.1.0
+Summary: Aver drift detection and rule-derived severity (F-40, F-41). Arrives in M2.
+License-Expression: Apache-2.0
+Requires-Dist: aver-core
+Requires-Python: >=3.11

aver_drift-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+aver_drift/__init__.py,sha256=I6AWBE7GtqX7dV3CLoGxv_pVv7vmvYHcuIfgFM_mSjE,611
+aver_drift/classify.py,sha256=iGdiHyeVfHpMPr_qTPPGtUGZ04tWGSXYf2zJnVetRjI,17062
+aver_drift/diff.py,sha256=JMxJp_gf8n_qLZKUfe6t8wE0-U6Pp85knbNuQcaCEaQ,4448
+aver_drift/policy.py,sha256=hC0uuyHVenl1WzFZ0B7UZf_gmzGMmVdGSq0ZuX2OyH8,3591
+aver_drift-0.1.0.dist-info/WHEEL,sha256=7hzKWg-J8I3Buqyw5tBii5z_MmAVsDYXXijd_QAtNZ8,81
+aver_drift-0.1.0.dist-info/METADATA,sha256=2tqiTTVn9PAj9onM1WHzAlhJif8JqsywdlaJb6lm_bc,219
+aver_drift-0.1.0.dist-info/RECORD,,

aver_drift-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.18
+Root-Is-Purelib: true
+Tag: py3-none-any