margin 0.9.2__tar.gz → 0.9.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.2
+Version: 0.9.4
 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.2 → margin-0.9.4}/margin/calibrate.py

@@ -157,10 +157,10 @@ def calibrate_many(
     use_std: bool = False,
     intact_std_multiplier: float = 1.5,
     ablated_std_multiplier: float = 3.0,
-) -> tuple[dict[str, float], dict[str, Thresholds]]:
+    return_parser: bool = False,
+):
     """
-    Calibrate multiple components at once. Returns (baselines, thresholds)
-    ready to pass directly to Parser().
+    Calibrate multiple components at once.
 
     Args:
         component_values:        {name: [healthy_measurements]}
@@ -171,12 +171,14 @@ def calibrate_many(
         use_std:                 if True, use std-based thresholds (see calibrate())
         intact_std_multiplier:   std deviations for intact threshold (std mode)
         ablated_std_multiplier:  std deviations for ablated threshold (std mode)
+        return_parser:           if True, return a ready-to-use Parser instead of the raw tuple
 
     Returns:
-        (baselines_dict, thresholds_dict) suitable for:
+        When return_parser=False (default): (baselines_dict, thresholds_dict) suitable for:
             Parser(baselines=baselines_dict,
                    thresholds=first_threshold,
                    component_thresholds=thresholds_dict)
+        When return_parser=True: a Parser with baselines and per-component thresholds set
     """
     polarities = polarities or {}
     baselines = {}
@@ -193,6 +195,18 @@ def calibrate_many(
         baselines[name] = result.baseline
         thresholds[name] = result.thresholds
 
+    if return_parser:
+        names = list(thresholds.keys())
+        if not names:
+            raise ValueError("No components to calibrate")
+        default_thresholds = thresholds[names[0]]
+        component_thresholds = {n: t for n, t in thresholds.items() if n != names[0]}
+        return Parser(
+            baselines=baselines,
+            thresholds=default_thresholds,
+            component_thresholds=component_thresholds,
+        )
+
     return baselines, thresholds
 
 

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

@@ -63,6 +63,29 @@ class Thresholds:
             return self.labels.get(health.value, health.value)
         return health.value
 
+    def to_dict(self) -> dict:
+        """Serialize to a plain dict (labels included if set)."""
+        d: dict = {
+            "intact": self.intact,
+            "ablated": self.ablated,
+            "higher_is_better": self.higher_is_better,
+            "active_min": self.active_min,
+        }
+        if self.labels:
+            d["labels"] = dict(self.labels)
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> 'Thresholds':
+        """Deserialize from a plain dict produced by to_dict()."""
+        return cls(
+            intact=d["intact"],
+            ablated=d["ablated"],
+            higher_is_better=d.get("higher_is_better", True),
+            active_min=d.get("active_min", 0.05),
+            labels=d.get("labels"),
+        )
+
     def __post_init__(self):
         if self.higher_is_better and self.ablated > self.intact:
             raise ValueError(

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

@@ -34,6 +34,26 @@ class WindowConfig:
     anomaly: Optional[int] = None
     correlation: Optional[int] = None
 
+    def to_dict(self) -> dict:
+        """Serialize to plain dict; omits None fields."""
+        d: dict = {}
+        if self.drift is not None:
+            d["drift"] = self.drift
+        if self.anomaly is not None:
+            d["anomaly"] = self.anomaly
+        if self.correlation is not None:
+            d["correlation"] = self.correlation
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> 'WindowConfig':
+        """Deserialize from a plain dict produced by to_dict()."""
+        return cls(
+            drift=d.get("drift"),
+            anomaly=d.get("anomaly"),
+            correlation=d.get("correlation"),
+        )
+
 from .confidence import Confidence
 from .health import Health, Thresholds, classify
 from .observation import Observation, Expression
@@ -478,18 +498,23 @@ class Monitor:
         return self._step
 
     def status(self) -> dict:
-        """Full snapshot: health + drift + anomaly + correlations."""
+        """Full snapshot: health + drift + anomaly + correlations.
+
+        Keys are always present; disabled features or no-data trackers
+        return empty dicts so callers can index without key-existence checks.
+        """
         d: dict = {
             "step": self._step,
             "expression": self._expression.to_dict() if self._expression else None,
+            "drift": {},
+            "anomaly": {},
+            "correlations": {},
         }
         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()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.2
+Version: 0.9.4
 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.2 → margin-0.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "margin"
-version = "0.9.2"
+version = "0.9.4"
 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"}

margin-0.9.4/tests/test_calibrate.py

@@ -0,0 +1,210 @@
+import pytest
+from margin.calibrate import calibrate, calibrate_many, parser_from_calibration, CalibrationResult
+from margin.health import Thresholds, Health
+from margin.confidence import Confidence
+
+
+class TestCalibrate:
+    def test_basic_higher_is_better(self):
+        r = calibrate([100.0, 100.0, 100.0])
+        assert r.baseline == pytest.approx(100.0)
+        assert r.thresholds.higher_is_better is True
+        assert r.thresholds.intact == pytest.approx(70.0)
+        assert r.thresholds.ablated == pytest.approx(30.0)
+
+    def test_basic_lower_is_better(self):
+        r = calibrate([0.01, 0.01, 0.01], higher_is_better=False)
+        assert r.baseline == pytest.approx(0.01)
+        assert r.thresholds.higher_is_better is False
+        # intact = 0.01 * 1.30 = 0.013
+        assert r.thresholds.intact == pytest.approx(0.013, abs=0.001)
+        # ablated = 0.01 * 1.70 = 0.017
+        assert r.thresholds.ablated == pytest.approx(0.017, abs=0.001)
+
+    def test_custom_fractions(self):
+        r = calibrate([200.0, 200.0], intact_fraction=0.80, ablated_fraction=0.20)
+        assert r.thresholds.intact == pytest.approx(160.0)
+        assert r.thresholds.ablated == pytest.approx(40.0)
+
+    def test_std_computed(self):
+        r = calibrate([90.0, 100.0, 110.0])
+        assert r.std > 0
+        assert r.n_samples == 3
+
+    def test_single_value(self):
+        r = calibrate([50.0])
+        assert r.baseline == 50.0
+        assert r.std == 0.0
+        assert r.n_samples == 1
+
+    def test_empty_raises(self):
+        with pytest.raises(ValueError):
+            calibrate([])
+
+    def test_to_dict(self):
+        r = calibrate([100.0, 100.0])
+        d = r.to_dict()
+        assert "baseline" in d
+        assert "intact" in d
+        assert "ablated" in d
+        assert "higher_is_better" in d
+
+    def test_threshold_validation_holds(self):
+        # Higher is better: ablated < intact
+        r = calibrate([100.0], higher_is_better=True)
+        assert r.thresholds.ablated <= r.thresholds.intact
+
+        # Lower is better: ablated > intact
+        r2 = calibrate([0.01], higher_is_better=False)
+        assert r2.thresholds.ablated >= r2.thresholds.intact
+
+
+class TestCalibrateMany:
+    def test_returns_baselines_and_thresholds(self):
+        baselines, thresholds = calibrate_many({
+            "throughput": [100.0, 105.0, 95.0],
+            "error_rate": [0.01, 0.012, 0.008],
+        }, polarities={"error_rate": False})
+
+        assert "throughput" in baselines
+        assert "error_rate" in baselines
+        assert thresholds["throughput"].higher_is_better is True
+        assert thresholds["error_rate"].higher_is_better is False
+
+    def test_default_polarity_is_higher(self):
+        _, thresholds = calibrate_many({"x": [50.0, 50.0]})
+        assert thresholds["x"].higher_is_better is True
+
+
+class TestParserFromCalibration:
+    def test_produces_working_parser(self):
+        parser = parser_from_calibration(
+            {"throughput": [100.0] * 5, "latency": [50.0] * 5},
+            polarities={"latency": False},
+        )
+        # Healthy readings
+        expr = parser.parse({"throughput": 95.0, "latency": 52.0})
+        assert expr.health_of("throughput") == Health.INTACT
+        assert expr.health_of("latency") == Health.INTACT
+
+    def test_detects_degradation(self):
+        parser = parser_from_calibration(
+            {"throughput": [100.0] * 5},
+        )
+        expr = parser.parse({"throughput": 40.0})
+        assert expr.health_of("throughput") == Health.DEGRADED
+
+    def test_empty_raises(self):
+        with pytest.raises(ValueError):
+            parser_from_calibration({})
+
+
+class TestCalibrateUseStd:
+    def test_higher_is_better_thresholds(self):
+        # mean=100, std=10 → intact=85 (100-1.5*10), ablated=70 (100-3*10)
+        r = calibrate([90.0, 100.0, 110.0], use_std=True)
+        assert r.thresholds.intact == pytest.approx(85.0, abs=0.1)
+        assert r.thresholds.ablated == pytest.approx(70.0, abs=0.1)
+        assert r.thresholds.higher_is_better is True
+
+    def test_lower_is_better_thresholds(self):
+        # mean=0.01, std=0.001 → intact=0.0115 (0.01+1.5*0.001), ablated=0.013 (0.01+3*0.001)
+        r = calibrate([0.009, 0.010, 0.011], use_std=True, higher_is_better=False)
+        assert r.thresholds.higher_is_better is False
+        assert r.thresholds.intact == pytest.approx(0.0115, abs=0.0001)
+        assert r.thresholds.ablated == pytest.approx(0.013, abs=0.0001)
+
+    def test_custom_multipliers(self):
+        # mean=100, std=10 → intact=100-2*10=80, ablated=100-4*10=60
+        r = calibrate([90.0, 100.0, 110.0], use_std=True,
+                      intact_std_multiplier=2.0, ablated_std_multiplier=4.0)
+        assert r.thresholds.intact == pytest.approx(80.0, abs=0.1)
+        assert r.thresholds.ablated == pytest.approx(60.0, abs=0.1)
+
+    def test_zero_variance_raises(self):
+        with pytest.raises(ValueError, match="zero-variance"):
+            calibrate([100.0, 100.0, 100.0], use_std=True)
+
+    def test_threads_through_calibrate_many(self):
+        from margin.calibrate import calibrate_many
+        _, thresholds = calibrate_many(
+            {"rps": [90.0, 100.0, 110.0]},
+            use_std=True,
+        )
+        # Should not raise; thresholds set from std mode
+        assert thresholds["rps"].intact < 100.0
+
+    def test_threads_through_parser_from_calibration(self):
+        p = parser_from_calibration(
+            {"rps": [90.0, 100.0, 110.0]},
+            use_std=True,
+        )
+        expr = p.parse({"rps": 60.0})
+        assert expr.health_of("rps") in (Health.ABLATED, Health.DEGRADED)
+
+
+class TestNeedsRecalibrationMany:
+    from margin.calibrate import needs_recalibration_many as _nrm
+
+    def test_stable_data_no_recalibration(self):
+        from margin.calibrate import needs_recalibration_many
+        cal = {"cpu": [50.0] * 20, "mem": [70.0] * 20}
+        recent = {"cpu": [50.5] * 10, "mem": [70.2] * 10}
+        flags = needs_recalibration_many(cal, recent)
+        assert flags["cpu"] is False
+        assert flags["mem"] is False
+
+    def test_mean_shift_triggers_recalibration(self):
+        from margin.calibrate import needs_recalibration_many
+        cal = {"cpu": [50.0] * 20}
+        recent = {"cpu": [100.0] * 10}  # >20% shift
+        flags = needs_recalibration_many(cal, recent)
+        assert flags["cpu"] is True
+
+    def test_returns_per_component_dict(self):
+        from margin.calibrate import needs_recalibration_many
+        cal = {"cpu": [50.0] * 20, "mem": [70.0] * 20, "err": [0.01] * 20}
+        recent = {"cpu": [50.0] * 10, "mem": [70.0] * 10, "err": [0.01] * 10}
+        flags = needs_recalibration_many(cal, recent)
+        assert set(flags.keys()) == {"cpu", "mem", "err"}
+        assert all(isinstance(v, bool) for v in flags.values())
+
+    def test_partial_subset_triggers(self):
+        from margin.calibrate import needs_recalibration_many
+        cal = {"cpu": [50.0] * 20, "mem": [70.0] * 20}
+        recent = {"cpu": [100.0] * 10, "mem": [70.1] * 10}
+        flags = needs_recalibration_many(cal, recent)
+        assert flags["cpu"] is True
+        assert flags["mem"] is False
+
+
+class TestCalibrateManyReturnParser:
+    def test_return_parser_gives_parser(self):
+        from margin.observation import Parser
+        result = calibrate_many(
+            {"rps": [90.0, 100.0, 110.0], "latency": [48.0, 50.0, 52.0]},
+            polarities={"latency": False},
+            return_parser=True,
+        )
+        assert isinstance(result, Parser)
+
+    def test_return_parser_classifies_correctly(self):
+        result = calibrate_many(
+            {"rps": [100.0] * 10, "latency": [50.0] * 10},
+            polarities={"latency": False},
+            return_parser=True,
+        )
+        from margin.health import Health
+        expr = result.parse({"rps": 95.0, "latency": 52.0})
+        assert expr.health_of("rps") == Health.INTACT
+        assert expr.health_of("latency") == Health.INTACT
+
+    def test_return_parser_false_gives_tuple(self):
+        result = calibrate_many({"rps": [100.0] * 5})
+        assert isinstance(result, tuple)
+        assert len(result) == 2
+
+    def test_return_parser_empty_raises(self):
+        import pytest
+        with pytest.raises(ValueError):
+            calibrate_many({}, return_parser=True)

{margin-0.9.2 → margin-0.9.4}/tests/test_health.py

@@ -97,3 +97,48 @@ class TestClassifyEdgeCases:
     def test_negative_inf_lower_is_better(self):
         t = Thresholds(intact=0.02, ablated=0.10, higher_is_better=False)
         assert classify(float('-inf'), Confidence.HIGH, thresholds=t) == Health.INTACT
+
+
+class TestThresholdsLabels:
+    def test_label_for_returns_custom(self):
+        t = Thresholds(intact=80.0, ablated=30.0, labels={"ABLATED": "CRITICAL", "INTACT": "OK"})
+        assert t.label_for(Health.ABLATED) == "CRITICAL"
+        assert t.label_for(Health.INTACT) == "OK"
+
+    def test_label_for_fallback_to_enum(self):
+        t = Thresholds(intact=80.0, ablated=30.0, labels={"ABLATED": "CRITICAL"})
+        assert t.label_for(Health.DEGRADED) == "DEGRADED"
+
+    def test_no_labels_returns_enum_name(self):
+        t = Thresholds(intact=80.0, ablated=30.0)
+        assert t.label_for(Health.INTACT) == "INTACT"
+
+    def test_to_dict_includes_labels(self):
+        t = Thresholds(intact=80.0, ablated=30.0, labels={"ABLATED": "CRITICAL"})
+        d = t.to_dict()
+        assert d["labels"] == {"ABLATED": "CRITICAL"}
+        assert d["intact"] == 80.0
+        assert d["ablated"] == 30.0
+        assert d["higher_is_better"] is True
+        assert d["active_min"] == pytest.approx(0.05)
+
+    def test_to_dict_omits_labels_when_none(self):
+        t = Thresholds(intact=80.0, ablated=30.0)
+        d = t.to_dict()
+        assert "labels" not in d
+
+    def test_from_dict_roundtrip(self):
+        t = Thresholds(intact=0.01, ablated=0.10, higher_is_better=False,
+                       active_min=0.1, labels={"INTACT": "GOOD", "DEGRADED": "WARN"})
+        t2 = Thresholds.from_dict(t.to_dict())
+        assert t2.intact == t.intact
+        assert t2.ablated == t.ablated
+        assert t2.higher_is_better == t.higher_is_better
+        assert t2.active_min == t.active_min
+        assert t2.labels == t.labels
+
+    def test_from_dict_no_labels(self):
+        t = Thresholds.from_dict({"intact": 80.0, "ablated": 30.0})
+        assert t.labels is None
+        assert t.higher_is_better is True
+        assert t.active_min == pytest.approx(0.05)

{margin-0.9.2 → margin-0.9.4}/tests/test_observation.py

@@ -210,3 +210,61 @@ class TestParserPolarity:
         e = p.parse({"throughput": 95.0, "err": 0.08}, correction_magnitude=1.0, alpha=0.5)
         assert e.corrections[0].target == "err"
         assert e.corrections[0].op == Op.RESTORE
+
+
+class TestHealthLabel:
+    def test_to_atom_uses_health_label(self):
+        obs = Observation(
+            name="cpu", health=Health.ABLATED, value=10.0, baseline=100.0,
+            confidence=Confidence.HIGH, health_label="CRITICAL",
+        )
+        atom = obs.to_atom()
+        assert "CRITICAL" in atom
+        assert "ABLATED" not in atom
+
+    def test_to_atom_fallback_when_no_label(self):
+        obs = Observation(
+            name="cpu", health=Health.DEGRADED, value=60.0, baseline=100.0,
+            confidence=Confidence.HIGH,
+        )
+        atom = obs.to_atom()
+        assert "DEGRADED" in atom
+
+    def test_parser_sets_health_label(self):
+        p = Parser(
+            baselines={"cpu": 100.0},
+            thresholds=Thresholds(
+                intact=80.0, ablated=30.0,
+                labels={"ABLATED": "CRITICAL", "DEGRADED": "WARNING", "INTACT": "OK"},
+            ),
+        )
+        expr = p.parse({"cpu": 10.0})
+        obs = expr.observations[0]
+        assert obs.health_label == "CRITICAL"
+        assert "CRITICAL" in obs.to_atom()
+
+    def test_parser_label_for(self):
+        p = Parser(
+            baselines={"cpu": 100.0},
+            thresholds=Thresholds(intact=80.0, ablated=30.0, labels={"INTACT": "OK"}),
+        )
+        assert p.label_for("cpu", Health.INTACT) == "OK"
+        assert p.label_for("cpu", Health.DEGRADED) == "DEGRADED"
+
+    def test_health_label_to_dict_roundtrip(self):
+        obs = Observation(
+            name="mem", health=Health.DEGRADED, value=60.0, baseline=100.0,
+            confidence=Confidence.HIGH, health_label="WARNING",
+        )
+        d = obs.to_dict()
+        assert d["health_label"] == "WARNING"
+        obs2 = Observation.from_dict(d)
+        assert obs2.health_label == "WARNING"
+
+    def test_health_label_none_not_in_dict(self):
+        obs = Observation(
+            name="mem", health=Health.INTACT, value=95.0, baseline=100.0,
+            confidence=Confidence.HIGH,
+        )
+        d = obs.to_dict()
+        assert "health_label" not in d

{margin-0.9.2 → margin-0.9.4}/tests/test_persist.py

@@ -214,3 +214,53 @@ class TestCLI:
         assert result.returncode == 0
         assert "cpu" in result.stdout
         assert "INTACT" in result.stdout or "DEGRADED" in result.stdout
+
+
+class TestFeaturesRoundtrip:
+    def test_partial_features_saved_and_restored(self):
+        p = _parser()
+        m = Monitor(p, features={"health", "drift"})
+        for i in range(10):
+            m.update({"cpu": 50.0 - i, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            save_monitor(m, f.name)
+            m2 = load_monitor(f.name, p)
+            Path(f.name).unlink()
+
+        assert m2.features == frozenset({"health", "drift"})
+        assert len(m2._drift_trackers) == 2
+        assert m2._correlation_tracker is None
+
+    def test_all_features_roundtrip(self):
+        p = _parser()
+        m = Monitor(p, features={"health", "drift", "anomaly", "correlation"})
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            save_monitor(m, f.name)
+            m2 = load_monitor(f.name, p)
+            Path(f.name).unlink()
+
+        assert "drift" in m2.features
+        assert "anomaly" in m2.features
+        assert "correlation" in m2.features
+
+    def test_anomaly_min_reference_roundtrip(self):
+        p = _parser()
+        m = Monitor(p, anomaly_min_reference=25)
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            save_monitor(m, f.name)
+            data = json.loads(Path(f.name).read_text())
+            m2 = load_monitor(f.name, p)
+            Path(f.name).unlink()
+
+        assert data["anomaly_min_reference"] == 25
+        assert m2._anomaly_trackers["cpu"]._min_reference == 25

{margin-0.9.2 → margin-0.9.4}/tests/test_policy_trace.py

@@ -136,3 +136,96 @@ class TestBacktestProposedBy:
         ledger = Ledger(records=[_rec(0, "x", Health.DEGRADED)])
         bt = policy.backtest(ledger)
         assert bt[0]["proposed_by"] == ""
+
+
+class TestMultiRule:
+    def _make_multi_policy(self):
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op
+        from margin.predicates import any_health, any_degraded
+        return Policy(
+            name="multi",
+            multi_rule=True,
+            rules=[
+                PolicyRule("log", any_degraded(),
+                           Action(target="*", op=Op.NOOP, alpha=0.0), priority=5),
+                PolicyRule("restore", any_health(Health.DEGRADED),
+                           Action(target="*", op=Op.RESTORE, alpha=0.5), priority=10),
+            ],
+        )
+
+    def test_multi_rule_all_matching_rules_fire(self):
+        policy = self._make_multi_policy()
+        dt = trace_evaluate(policy, _expr(_obs("x", Health.DEGRADED)))
+        # Both rules match DEGRADED
+        assert len(dt.results) == 2
+
+    def test_multi_rule_winner_is_highest_priority(self):
+        policy = self._make_multi_policy()
+        dt = trace_evaluate(policy, _expr(_obs("x", Health.DEGRADED)))
+        assert dt.winner == "restore"
+        assert dt.result is not None
+
+    def test_trace_always_has_all_matched_results(self):
+        # trace_evaluate always populates dt.results for all matches;
+        # multi_rule only gates StepResult.corrections in step()
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op
+        from margin.predicates import any_degraded
+        policy = Policy(
+            name="single",
+            multi_rule=False,
+            rules=[
+                PolicyRule("r1", any_degraded(), Action(target="*", op=Op.RESTORE, alpha=0.5), priority=10),
+                PolicyRule("r2", any_degraded(), Action(target="*", op=Op.NOOP), priority=5),
+            ],
+        )
+        dt = trace_evaluate(policy, _expr(_obs("x", Health.DEGRADED)))
+        # Both rules match — trace always records all; multi_rule only affects step()
+        assert len(dt.results) == 2
+        assert dt.winner == "r1"  # highest priority still wins
+
+    def test_multi_rule_to_dict_includes_multi_rule_flag(self):
+        policy = self._make_multi_policy()
+        d = policy.to_dict()
+        assert d["multi_rule"] is True
+
+    def test_multi_rule_default_is_false(self):
+        from margin.policy.core import Policy
+        policy = Policy(name="p", rules=[])
+        assert policy.multi_rule is False
+        assert policy.to_dict()["multi_rule"] is False
+
+
+class TestStepResultCorrections:
+    def test_step_corrections_populated_multi_rule(self):
+        from margin.loop import step
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op
+        from margin.predicates import any_degraded
+
+        policy = Policy(
+            name="multi",
+            multi_rule=True,
+            rules=[
+                PolicyRule("r1", any_degraded(), Action(target="*", op=Op.RESTORE, alpha=0.5), priority=10),
+                PolicyRule("r2", any_degraded(), Action(target="*", op=Op.NOOP), priority=5),
+            ],
+        )
+        result = step(_expr(_obs("x", Health.DEGRADED)), policy)
+        assert len(result.corrections) >= 1
+
+    def test_step_corrections_empty_single_rule(self):
+        from margin.loop import step
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op
+        from margin.predicates import any_degraded
+
+        policy = Policy(
+            name="single",
+            multi_rule=False,
+            rules=[PolicyRule("r", any_degraded(), Action(target="*", op=Op.RESTORE, alpha=0.5))],
+        )
+        result = step(_expr(_obs("x", Health.DEGRADED)), policy)
+        # multi_rule=False → corrections list is empty (only .correction populated)
+        assert result.corrections == []

{margin-0.9.2 → margin-0.9.4}/tests/test_streaming.py

@@ -6,6 +6,7 @@ from margin import (
     Observation, Health, Confidence, Thresholds, Parser,
     DriftState, DriftDirection, AnomalyState,
     DriftTracker, AnomalyTracker, CorrelationTracker, Monitor,
+    WindowConfig,
 )
 
 
@@ -284,3 +285,166 @@ class TestMonitor:
         m = Monitor(self._parser())
         assert "Monitor" in repr(m)
         assert "3 components" in repr(m)
+
+
+# -----------------------------------------------------------------------
+# Monitor — feature flags
+# -----------------------------------------------------------------------
+
+class TestMonitorFeatures:
+    def _parser(self):
+        return Parser(
+            baselines={"cpu": 50.0, "mem": 70.0},
+            thresholds=Thresholds(intact=40.0, ablated=10.0),
+        )
+
+    def test_default_features_all_enabled(self):
+        m = Monitor(self._parser())
+        assert "drift" in m.features
+        assert "anomaly" in m.features
+        assert "correlation" in m.features
+
+    def test_features_health_only_skips_trackers(self):
+        m = Monitor(self._parser(), features={"health"})
+        assert len(m._drift_trackers) == 0
+        assert len(m._anomaly_trackers) == 0
+        assert m._correlation_tracker is None
+
+    def test_features_health_drift_no_anomaly(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        assert len(m._drift_trackers) == 2
+        assert len(m._anomaly_trackers) == 0
+        assert m._correlation_tracker is None
+
+    def test_features_health_anomaly_no_drift(self):
+        m = Monitor(self._parser(), features={"health", "anomaly"})
+        assert len(m._drift_trackers) == 0
+        assert len(m._anomaly_trackers) == 2
+
+    def test_update_works_with_partial_features(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        expr = m.update({"cpu": 48.0, "mem": 65.0})
+        assert expr is not None
+        assert m.step == 1
+
+    def test_features_is_frozenset(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        assert isinstance(m.features, frozenset)
+
+    def test_status_always_has_drift_anomaly_correlations_keys(self):
+        m = Monitor(self._parser(), features={"health"})
+        for i in range(5):
+            m.update({"cpu": 50.0 - i, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+        s = m.status()
+        # Keys always present — empty dict when feature disabled or no data yet
+        assert "drift" in s and s["drift"] == {}
+        assert "anomaly" in s and s["anomaly"] == {}
+        assert "correlations" in s and s["correlations"] == {}
+
+    def test_repr_shows_features_when_partial(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        r = repr(m)
+        assert "features" in r
+
+    def test_repr_no_features_label_when_all_enabled(self):
+        m = Monitor(self._parser())
+        r = repr(m)
+        assert "features" not in r
+
+    def test_reset_works_with_partial_features(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        for i in range(5):
+            m.update({"cpu": 50.0 - i, "mem": 70.0})
+        m.reset()
+        assert m.step == 0
+
+
+# -----------------------------------------------------------------------
+# Monitor — reset_anomaly_reference
+# -----------------------------------------------------------------------
+
+class TestMonitorResetAnomalyReference:
+    def _parser(self):
+        return Parser(
+            baselines={"cpu": 50.0, "mem": 70.0},
+            thresholds=Thresholds(intact=40.0, ablated=10.0),
+        )
+
+    def test_reset_clears_all_reference_values(self):
+        m = Monitor(self._parser(), anomaly_min_reference=5)
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+        assert m._anomaly_trackers["cpu"].n_values == 10
+        m.reset_anomaly_reference()
+        assert m._anomaly_trackers["cpu"].n_values == 0
+        assert m._anomaly_trackers["mem"].n_values == 0
+
+    def test_reset_specific_components(self):
+        m = Monitor(self._parser(), anomaly_min_reference=5)
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+        m.reset_anomaly_reference(components=["cpu"])
+        assert m._anomaly_trackers["cpu"].n_values == 0
+        assert m._anomaly_trackers["mem"].n_values == 10
+
+    def test_reset_allows_fresh_reference(self):
+        m = Monitor(self._parser(), anomaly_min_reference=5)
+        # Build reference at baseline=50
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+        m.reset_anomaly_reference()
+        # Feed new baseline at 100 — should warm up without contamination
+        for i in range(10):
+            m.update({"cpu": 100.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=(20 + i) * 60))
+        assert m._anomaly_trackers["cpu"].n_values == 10
+
+    def test_reset_noop_when_anomaly_disabled(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        # Should not raise even though anomaly trackers don't exist
+        m.reset_anomaly_reference()
+
+
+# -----------------------------------------------------------------------
+# WindowConfig serialization
+# -----------------------------------------------------------------------
+
+class TestWindowConfigSerialization:
+    def test_to_dict_full(self):
+        wc = WindowConfig(drift=10, anomaly=40, correlation=100)
+        d = wc.to_dict()
+        assert d == {"drift": 10, "anomaly": 40, "correlation": 100}
+
+    def test_to_dict_partial(self):
+        wc = WindowConfig(drift=10)
+        d = wc.to_dict()
+        assert d == {"drift": 10}
+        assert "anomaly" not in d
+        assert "correlation" not in d
+
+    def test_to_dict_empty(self):
+        wc = WindowConfig()
+        assert wc.to_dict() == {}
+
+    def test_from_dict_roundtrip(self):
+        wc = WindowConfig(drift=10, anomaly=40, correlation=100)
+        wc2 = WindowConfig.from_dict(wc.to_dict())
+        assert wc2.drift == 10
+        assert wc2.anomaly == 40
+        assert wc2.correlation == 100
+
+    def test_from_dict_partial(self):
+        wc = WindowConfig.from_dict({"drift": 20})
+        assert wc.drift == 20
+        assert wc.anomaly is None
+        assert wc.correlation is None
+
+    def test_from_dict_empty(self):
+        wc = WindowConfig.from_dict({})
+        assert wc.drift is None
+        assert wc.anomaly is None
+        assert wc.correlation is None

margin-0.9.2/tests/test_calibrate.py

@@ -1,99 +0,0 @@
-import pytest
-from margin.calibrate import calibrate, calibrate_many, parser_from_calibration, CalibrationResult
-from margin.health import Thresholds, Health
-from margin.confidence import Confidence
-
-
-class TestCalibrate:
-    def test_basic_higher_is_better(self):
-        r = calibrate([100.0, 100.0, 100.0])
-        assert r.baseline == pytest.approx(100.0)
-        assert r.thresholds.higher_is_better is True
-        assert r.thresholds.intact == pytest.approx(70.0)
-        assert r.thresholds.ablated == pytest.approx(30.0)
-
-    def test_basic_lower_is_better(self):
-        r = calibrate([0.01, 0.01, 0.01], higher_is_better=False)
-        assert r.baseline == pytest.approx(0.01)
-        assert r.thresholds.higher_is_better is False
-        # intact = 0.01 * 1.30 = 0.013
-        assert r.thresholds.intact == pytest.approx(0.013, abs=0.001)
-        # ablated = 0.01 * 1.70 = 0.017
-        assert r.thresholds.ablated == pytest.approx(0.017, abs=0.001)
-
-    def test_custom_fractions(self):
-        r = calibrate([200.0, 200.0], intact_fraction=0.80, ablated_fraction=0.20)
-        assert r.thresholds.intact == pytest.approx(160.0)
-        assert r.thresholds.ablated == pytest.approx(40.0)
-
-    def test_std_computed(self):
-        r = calibrate([90.0, 100.0, 110.0])
-        assert r.std > 0
-        assert r.n_samples == 3
-
-    def test_single_value(self):
-        r = calibrate([50.0])
-        assert r.baseline == 50.0
-        assert r.std == 0.0
-        assert r.n_samples == 1
-
-    def test_empty_raises(self):
-        with pytest.raises(ValueError):
-            calibrate([])
-
-    def test_to_dict(self):
-        r = calibrate([100.0, 100.0])
-        d = r.to_dict()
-        assert "baseline" in d
-        assert "intact" in d
-        assert "ablated" in d
-        assert "higher_is_better" in d
-
-    def test_threshold_validation_holds(self):
-        # Higher is better: ablated < intact
-        r = calibrate([100.0], higher_is_better=True)
-        assert r.thresholds.ablated <= r.thresholds.intact
-
-        # Lower is better: ablated > intact
-        r2 = calibrate([0.01], higher_is_better=False)
-        assert r2.thresholds.ablated >= r2.thresholds.intact
-
-
-class TestCalibrateMany:
-    def test_returns_baselines_and_thresholds(self):
-        baselines, thresholds = calibrate_many({
-            "throughput": [100.0, 105.0, 95.0],
-            "error_rate": [0.01, 0.012, 0.008],
-        }, polarities={"error_rate": False})
-
-        assert "throughput" in baselines
-        assert "error_rate" in baselines
-        assert thresholds["throughput"].higher_is_better is True
-        assert thresholds["error_rate"].higher_is_better is False
-
-    def test_default_polarity_is_higher(self):
-        _, thresholds = calibrate_many({"x": [50.0, 50.0]})
-        assert thresholds["x"].higher_is_better is True
-
-
-class TestParserFromCalibration:
-    def test_produces_working_parser(self):
-        parser = parser_from_calibration(
-            {"throughput": [100.0] * 5, "latency": [50.0] * 5},
-            polarities={"latency": False},
-        )
-        # Healthy readings
-        expr = parser.parse({"throughput": 95.0, "latency": 52.0})
-        assert expr.health_of("throughput") == Health.INTACT
-        assert expr.health_of("latency") == Health.INTACT
-
-    def test_detects_degradation(self):
-        parser = parser_from_calibration(
-            {"throughput": [100.0] * 5},
-        )
-        expr = parser.parse({"throughput": 40.0})
-        assert expr.health_of("throughput") == Health.DEGRADED
-
-    def test_empty_raises(self):
-        with pytest.raises(ValueError):
-            parser_from_calibration({})