margin 0.9.1__tar.gz → 0.9.2__tar.gz

{margin-0.9.1/margin.egg-info → margin-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.1
+Version: 0.9.2
 Summary: Typed health classification, uncertainty algebra, and correction auditing for any system that measures things and needs to explain what happened.
 Author: Cope Labs LLC
 License: MIT

{margin-0.9.1 → margin-0.9.2}/margin/health.py

@@ -46,6 +46,7 @@ class Thresholds:
                       (throughput, signal), False means lower values are
                       healthier (error rate, latency)
     active_min:       minimum correction magnitude to count as "active"
+    labels:           optional display labels keyed by Health.value strings
 
     For higher_is_better=True:  intact >= ablated, value >= intact → INTACT
     For higher_is_better=False: intact <= ablated, value <= intact → INTACT
@@ -54,6 +55,13 @@ class Thresholds:
     ablated: float
     higher_is_better: bool = True
     active_min: float = 0.05
+    labels: Optional[dict[str, str]] = None
+
+    def label_for(self, health: 'Health') -> str:
+        """Return the display label for a health state, or the state name if no label set."""
+        if self.labels:
+            return self.labels.get(health.value, health.value)
+        return health.value
 
     def __post_init__(self):
         if self.higher_is_better and self.ablated > self.intact:

{margin-0.9.1 → margin-0.9.2}/margin/loop.py

@@ -45,6 +45,7 @@ class StepResult:
     correction: Optional[Correction] = None
     escalation: Optional[Escalation] = None
     contract: Optional[ContractResult] = None
+    corrections: list = field(default_factory=list)  # all fired corrections (multi_rule)
 
     @property
     def acted(self) -> bool:
@@ -74,6 +75,8 @@ class StepResult:
             d["decision"] = self.decision.to_dict()
         if self.correction:
             d["correction"] = self.correction.to_dict()
+        if self.corrections:
+            d["corrections"] = [c.to_dict() for c in self.corrections]
         if self.escalation:
             d["escalation"] = self.escalation.to_dict()
         if self.contract:
@@ -140,6 +143,11 @@ def step(
     elif isinstance(decision.result, Escalation):
         escalation = decision.result
 
+    # Collect all corrections for multi_rule mode
+    all_corrections = []
+    if policy.multi_rule:
+        all_corrections = [r for r in decision.results if isinstance(r, Correction)]
+
     # 3. Evaluate contract
     contract_result = None
     if contract:
@@ -152,6 +160,7 @@ def step(
         correction=correction,
         escalation=escalation,
         contract=contract_result,
+        corrections=all_corrections,
     )
 
 

{margin-0.9.1 → margin-0.9.2}/margin/observation.py

@@ -60,6 +60,7 @@ class Observation:
     higher_is_better: bool = True
     provenance: list[str] = field(default_factory=list)
     measured_at: Optional[datetime] = None
+    health_label: Optional[str] = None
 
     @property
     def sigma(self) -> float:
@@ -91,10 +92,11 @@ class Observation:
 
     def to_atom(self) -> str:
         """Compact string: NAME:HEALTH(±σ)"""
+        display = self.health_label or self.health.value
         if self.health == Health.OOD:
-            return f"{self.name}:{self.health.value}"
+            return f"{self.name}:{display}"
         sign = "+" if self.sigma >= 0 else ""
-        return f"{self.name}:{self.health.value}({sign}{self.sigma:.2f}σ)"
+        return f"{self.name}:{display}({sign}{self.sigma:.2f}σ)"
 
     def to_dict(self) -> dict:
         d = {
@@ -107,6 +109,8 @@ class Observation:
             "higher_is_better": self.higher_is_better,
             "provenance": self.provenance,
         }
+        if self.health_label is not None:
+            d["health_label"] = self.health_label
         if self.measured_at is not None:
             d["measured_at"] = self.measured_at.isoformat()
         return d
@@ -125,6 +129,7 @@ class Observation:
             higher_is_better=d.get("higher_is_better", True),
             provenance=d.get("provenance", []),
             measured_at=measured_at,
+            health_label=d.get("health_label"),
         )
 
 
@@ -311,6 +316,10 @@ class Parser:
     def _thresholds_for(self, name: str) -> Thresholds:
         return self.component_thresholds.get(name, self.thresholds)
 
+    def label_for(self, component: str, health: Health) -> str:
+        """Return the display label for a component's health state."""
+        return self._thresholds_for(component).label_for(health)
+
     def parse(
         self,
         values: dict[str, float],
@@ -343,6 +352,7 @@ class Parser:
                 name=name, health=h, value=val, baseline=baseline,
                 confidence=conf, higher_is_better=ct.higher_is_better,
                 provenance=list(provenance),
+                health_label=ct.label_for(h) if ct.labels else None,
             ))
 
         corrections = []

{margin-0.9.1 → margin-0.9.2}/margin/persist.py

@@ -33,13 +33,14 @@ def save_monitor(monitor: Monitor, path: str) -> None:
         "anomaly_window": monitor.anomaly_window,
         "correlation_window": monitor.correlation_window,
         "anomaly_min_reference": _anomaly_min_ref,
+        "features": sorted(monitor.features),
         "drift": {},
         "anomaly": {},
         "correlation": {
             "components": monitor._correlation_tracker.components,
             "series": {c: list(d) for c, d in monitor._correlation_tracker._series.items()},
             "n_updates": monitor._correlation_tracker.n_updates,
-        },
+        } if monitor._correlation_tracker is not None else None,
     }
 
     for name, dt in monitor._drift_trackers.items():
@@ -71,12 +72,15 @@ def load_monitor(path: str, parser: Parser, **kwargs) -> Monitor:
     anomaly_window = data.get("anomaly_window", kwargs.pop("anomaly_window", None))
     correlation_window = data.get("correlation_window", kwargs.pop("correlation_window", None))
     anomaly_min_reference = data.get("anomaly_min_reference", kwargs.pop("anomaly_min_reference", 10))
+    features_data = data.get("features", None)
+    features = set(features_data) if features_data is not None else None
     monitor = Monitor(
         parser, window=window,
         drift_window=drift_window,
         anomaly_window=anomaly_window,
         correlation_window=correlation_window,
         anomaly_min_reference=anomaly_min_reference,
+        features=features,
         **kwargs,
     )
     monitor._step = data.get("step", 0)
@@ -101,12 +105,13 @@ def load_monitor(path: str, parser: Parser, **kwargs) -> Monitor:
                 tracker._values.append(v)
 
     # Restore correlation series
-    corr_data = data.get("correlation", {})
-    for c in monitor._correlation_tracker.components:
-        series = corr_data.get("series", {}).get(c, [])
-        for v in series:
-            monitor._correlation_tracker._series[c].append(v)
-    monitor._correlation_tracker._n_updates = corr_data.get("n_updates", 0)
+    corr_data = data.get("correlation")
+    if corr_data is not None and monitor._correlation_tracker is not None:
+        for c in monitor._correlation_tracker.components:
+            series = corr_data.get("series", {}).get(c, [])
+            for v in series:
+                monitor._correlation_tracker._series[c].append(v)
+        monitor._correlation_tracker._n_updates = corr_data.get("n_updates", 0)
 
     return monitor
 

{margin-0.9.1 → margin-0.9.2}/margin/policy/core.py

@@ -258,6 +258,7 @@ class Policy:
     rules: list[PolicyRule] = field(default_factory=list)
     default_constraint: Optional[Constraint] = None
     default_escalation: Optional[Escalation] = None
+    multi_rule: bool = False
 
     def evaluate(self, expr: Expression, ledger: Optional[Ledger] = None) -> list[Union[Correction, Escalation]]:
         matching = sorted([r for r in self.rules if r.matches(expr)],
@@ -305,7 +306,7 @@ class Policy:
         return results
 
     def to_dict(self) -> dict:
-        d: dict = {"name": self.name, "rules": [r.to_dict() for r in self.rules]}
+        d: dict = {"name": self.name, "rules": [r.to_dict() for r in self.rules], "multi_rule": self.multi_rule}
         if self.default_constraint:
             d["default_constraint"] = self.default_constraint.to_dict()
         if self.default_escalation:
@@ -324,6 +325,7 @@ class Policy:
             name=d["name"], rules=rules,
             default_constraint=Constraint.from_dict(d["default_constraint"]) if "default_constraint" in d else None,
             default_escalation=Escalation.from_dict(d["default_escalation"]) if "default_escalation" in d else None,
+            multi_rule=d.get("multi_rule", False),
         )
 
     def __repr__(self) -> str:

{margin-0.9.1 → margin-0.9.2}/margin/policy/trace.py

@@ -59,6 +59,7 @@ class DecisionTrace:
     winner: Optional[str] = None
     result: Optional[Union[Correction, Escalation]] = None
     causal_context: Optional[dict] = None  # from causal.explain_all() if available
+    results: list = field(default_factory=list)  # all fired corrections/escalations (multi_rule)
 
     @property
     def rules_considered(self) -> int:
@@ -111,6 +112,11 @@ class DecisionTrace:
             d["result_type"] = None
         if self.causal_context:
             d["causal_context"] = self.causal_context
+        if self.results:
+            d["results"] = [
+                r.to_dict() if hasattr(r, 'to_dict') else str(r)
+                for r in self.results
+            ]
         return d
 
     def __repr__(self) -> str:
@@ -132,12 +138,12 @@ def trace_evaluate(
     attached to the trace for auditability.
     """
     dt = DecisionTrace(expression=expr, causal_context=causal_context)
-    winner_result = None
-    winner_name = None
 
     # Evaluate all rules in priority order
     sorted_rules = sorted(policy.rules, key=lambda r: r.priority, reverse=True)
 
+    all_results = []
+
     for rule in sorted_rules:
         matched = rule.matches(expr)
         ev = RuleEvaluation(
@@ -156,26 +162,24 @@ def trace_evaluate(
                     ev.outcome = "escalation"
                     ev.reason = f"{result.level.value}: {result.reason}"
                 ev.result = result
-
-                if winner_result is None:
-                    winner_result = result
-                    winner_name = rule.name
+                all_results.append((rule.name, result))
             else:
                 ev.outcome = "suppressed"
                 ev.reason = "evaluate returned None"
 
         dt.evaluations.append(ev)
 
-    if winner_result is None and policy.default_escalation:
-        winner_result = Escalation(
+    if not all_results and policy.default_escalation:
+        default_esc = Escalation(
             policy.default_escalation.level,
             policy.default_escalation.reason,
             "default",
         )
-        winner_name = "default"
+        all_results.append(("default", default_esc))
 
-    dt.winner = winner_name
-    dt.result = winner_result
+    dt.results = [r for _, r in all_results]
+    dt.winner = all_results[0][0] if all_results else None
+    dt.result = all_results[0][1] if all_results else None
     return dt
 
 

{margin-0.9.1 → margin-0.9.2}/margin/streaming.py

@@ -364,6 +364,7 @@ class Monitor:
         window_config: Optional[WindowConfig] = None,
         min_correlation: float = 0.7,
         anomaly_min_reference: int = 10,
+        features: Optional[set] = None,
     ):
         self.parser = parser
         self.window = window
@@ -374,7 +375,10 @@ class Monitor:
         self.anomaly_window = cfg.anomaly or anomaly_window or window
         self.correlation_window = cfg.correlation or correlation_window or window
 
-        if anomaly_min_reference > self.anomaly_window:
+        # Resolve feature flags: None means all enabled (backward compatible)
+        self.features = frozenset(features) if features is not None else frozenset({"drift", "anomaly", "correlation"})
+
+        if "anomaly" in self.features and anomaly_min_reference > self.anomaly_window:
             warnings.warn(
                 f"Monitor: anomaly_min_reference={anomaly_min_reference} > "
                 f"anomaly_window={self.anomaly_window} — AnomalyTrackers will never "
@@ -386,22 +390,28 @@ class Monitor:
         self._expression: Optional[Expression] = None
         self._step = 0
 
-        # Create per-component trackers
+        # Create per-component trackers for enabled features only
         self._drift_trackers: dict[str, DriftTracker] = {}
         self._anomaly_trackers: dict[str, AnomalyTracker] = {}
 
-        for name in parser.baselines:
-            self._drift_trackers[name] = DriftTracker(name, window=self.drift_window)
-            self._anomaly_trackers[name] = AnomalyTracker(
-                name, window=self.anomaly_window, min_reference=anomaly_min_reference,
-            )
+        if "drift" in self.features:
+            for name in parser.baselines:
+                self._drift_trackers[name] = DriftTracker(name, window=self.drift_window)
 
-        # Correlation tracker across all components
-        self._correlation_tracker = CorrelationTracker(
-            list(parser.baselines.keys()),
-            window=self.correlation_window,
-            min_correlation=min_correlation,
-        )
+        if "anomaly" in self.features:
+            for name in parser.baselines:
+                self._anomaly_trackers[name] = AnomalyTracker(
+                    name, window=self.anomaly_window, min_reference=anomaly_min_reference,
+                )
+
+        if "correlation" in self.features:
+            self._correlation_tracker: Optional[CorrelationTracker] = CorrelationTracker(
+                list(parser.baselines.keys()),
+                window=self.correlation_window,
+                min_correlation=min_correlation,
+            )
+        else:
+            self._correlation_tracker = None
 
     def update(
         self,
@@ -440,7 +450,8 @@ class Monitor:
                 self._anomaly_trackers[name].update(obs.value)
 
         # Correlation
-        self._correlation_tracker.update(values)
+        if self._correlation_tracker is not None:
+            self._correlation_tracker.update(values)
 
         return self._expression
 
@@ -458,6 +469,8 @@ class Monitor:
 
     @property
     def correlations(self) -> Optional[CorrelationMatrix]:
+        if self._correlation_tracker is None:
+            return None
         return self._correlation_tracker.matrix
 
     @property
@@ -469,16 +482,18 @@ class Monitor:
         d: dict = {
             "step": self._step,
             "expression": self._expression.to_dict() if self._expression else None,
-            "drift": {},
-            "anomaly": {},
         }
-        for name, tracker in self._drift_trackers.items():
-            if tracker.classification:
-                d["drift"][name] = tracker.classification.to_dict()
-        for name, tracker in self._anomaly_trackers.items():
-            if tracker.classification:
-                d["anomaly"][name] = tracker.classification.to_dict()
-        if self._correlation_tracker.matrix:
+        if "drift" in self.features:
+            d["drift"] = {}
+            for name, tracker in self._drift_trackers.items():
+                if tracker.classification:
+                    d["drift"][name] = tracker.classification.to_dict()
+        if "anomaly" in self.features:
+            d["anomaly"] = {}
+            for name, tracker in self._anomaly_trackers.items():
+                if tracker.classification:
+                    d["anomaly"][name] = tracker.classification.to_dict()
+        if self._correlation_tracker is not None and self._correlation_tracker.matrix:
             d["correlations"] = self._correlation_tracker.matrix.to_dict()
         return d
 
@@ -506,7 +521,8 @@ class Monitor:
             t.reset()
         for t in self._anomaly_trackers.values():
             t.reset()
-        self._correlation_tracker.reset()
+        if self._correlation_tracker is not None:
+            self._correlation_tracker.reset()
 
     def __repr__(self) -> str:
         windows_uniform = (self.drift_window == self.anomaly_window == self.correlation_window)
@@ -514,4 +530,9 @@ class Monitor:
             w = f"window={self.drift_window}"
         else:
             w = f"drift={self.drift_window}, anomaly={self.anomaly_window}, corr={self.correlation_window}"
-        return f"Monitor(step={self._step}, {len(self._drift_trackers)} components, {w})"
+        all_features = frozenset({"drift", "anomaly", "correlation"})
+        if self.features == all_features:
+            feat = ""
+        else:
+            feat = f", features={{{', '.join(sorted(self.features))}}}"
+        return f"Monitor(step={self._step}, {len(self._drift_trackers)} components, {w}{feat})"

{margin-0.9.1 → margin-0.9.2/margin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.1
+Version: 0.9.2
 Summary: Typed health classification, uncertainty algebra, and correction auditing for any system that measures things and needs to explain what happened.
 Author: Cope Labs LLC
 License: MIT

{margin-0.9.1 → margin-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "margin"
-version = "0.9.1"
+version = "0.9.2"
 description = "Typed health classification, uncertainty algebra, and correction auditing for any system that measures things and needs to explain what happened."
 readme = "README.md"
 license = {text = "MIT"}