margin 0.9.2__tar.gz → 0.9.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.2
+Version: 0.9.3
 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.3}/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.3/margin.egg-info}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "margin"
-version = "0.9.2"
+version = "0.9.3"
 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.2 → margin-0.9.3}/tests/test_calibrate.py

@@ -97,3 +97,82 @@ class TestParserFromCalibration:
     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

{margin-0.9.2 → margin-0.9.3}/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.3}/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.3}/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.3}/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.3}/tests/test_streaming.py

@@ -284,3 +284,124 @@ 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_omits_disabled_feature_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()
+        # drift disabled → "drift" key absent
+        assert "drift" not in s
+        assert "anomaly" not in s
+
+    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()