margin 0.9.6__tar.gz → 0.9.8__tar.gz

{margin-0.9.6/margin.egg-info → margin-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.6
+Version: 0.9.8
 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.6 → margin-0.9.8}/margin/config.py

@@ -125,6 +125,7 @@ def from_config(config: dict) -> dict:
             intact=spec.get("intact", default_intact),
             ablated=spec.get("ablated", default_ablated),
             higher_is_better=hib,
+            labels=spec.get("labels"),
         )
 
     # Use first component's thresholds as default (or the explicit default)
@@ -153,6 +154,8 @@ def from_config(config: dict) -> dict:
                 op=Op(action_spec.get("op", "RESTORE")),
                 alpha=action_spec.get("alpha", 0.5),
                 magnitude=action_spec.get("magnitude", 1.0),
+                alpha_from_sigma=action_spec.get("alpha_from_sigma", False),
+                magnitude_from_sigma=action_spec.get("magnitude_from_sigma", False),
             )
             constraint = None
             if "constraint" in spec:
@@ -171,6 +174,8 @@ def from_config(config: dict) -> dict:
                     level=EscalationLevel(es.get("level", "LOG")),
                     reason=es.get("reason", ""),
                 )
+            min_conf_str = spec.get("min_confidence")
+            min_confidence = Confidence(min_conf_str) if min_conf_str else Confidence.LOW
             rules.append(PolicyRule(
                 name=spec["name"],
                 predicate=predicate,
@@ -178,8 +183,13 @@ def from_config(config: dict) -> dict:
                 priority=spec.get("priority", 0),
                 constraint=constraint,
                 escalation=escalation,
+                min_confidence=min_confidence,
             ))
-        result["policy"] = Policy(name=config.get("name", "config-policy"), rules=rules)
+        result["policy"] = Policy(
+            name=config.get("name", "config-policy"),
+            rules=rules,
+            multi_rule=config.get("multi_rule", False),
+        )
 
     # --- Contract ---
     contract_specs = config.get("contract", [])

{margin-0.9.6 → margin-0.9.8}/margin/contract.py

@@ -352,5 +352,12 @@ class Contract:
     def to_dict(self) -> dict:
         return {"name": self.name, "terms": [t.to_dict() for t in self.terms]}
 
+    @classmethod
+    def from_dict(cls, d: dict) -> 'Contract':
+        return cls(
+            name=d.get("name", ""),
+            terms=[contract_term_from_dict(t) for t in d.get("terms", [])],
+        )
+
     def __repr__(self) -> str:
         return f"Contract({self.name!r}, {len(self.terms)} terms)"

{margin-0.9.6 → margin-0.9.8}/margin/ledger.py

@@ -211,11 +211,11 @@ class Ledger:
             "n_harmful": len(self.harmful()),
         }
 
+    def to_dict(self) -> dict:
+        return {"label": self.label, "records": [r.to_dict() for r in self.records]}
+
     def to_json(self, indent: int = 2) -> str:
-        return json.dumps({
-            "label": self.label,
-            "records": [r.to_dict() for r in self.records],
-        }, indent=indent)
+        return json.dumps(self.to_dict(), indent=indent)
 
     @classmethod
     def from_dict(cls, d: dict) -> 'Ledger':

{margin-0.9.6 → margin-0.9.8}/margin/loop.py

@@ -250,6 +250,8 @@ class FullStepResult:
             d["drift"] = {k: v.to_dict() for k, v in self.drift.items()}
         if self.anomaly:
             d["anomaly"] = {k: v.to_dict() for k, v in self.anomaly.items()}
+        if self.correlations is not None and self.correlations.to_dict():
+            d["correlations"] = self.correlations.to_dict()
         if self.intent:
             d["intent"] = self.intent.to_dict()
         return d
@@ -292,14 +294,17 @@ def full_step(
       3. Intent.evaluate() → goal feasibility
 
     Args:
-        monitor:   streaming Monitor
-        values:    raw measurements {component: value}
-        policy:    decision policy
-        ledger:    correction ledger (optional)
-        graph:     causal graph (optional)
-        contract:  success contract (optional)
-        intent:    Intent goal (optional)
-        now:       current timestamp (optional)
+        monitor:      streaming Monitor
+        values:       raw measurements {component: value}
+        policy:       decision policy
+        ledger:       correction ledger (optional)
+        graph:        causal graph (optional)
+        contract:     success contract (optional)
+        intent:       Intent goal (optional)
+        now:          current timestamp (optional)
+        confidences:  per-component Confidence overrides (optional)
+        provenance:   provenance tags for all observations (optional)
+        label:        expression label for this step (optional)
 
     Returns FullStepResult with all stages evaluated.
     """

{margin-0.9.6 → margin-0.9.8}/margin/observation.py

@@ -333,10 +333,13 @@ class Parser:
         """
         Parse a set of component measurements into a typed Expression.
 
-        values:     {component_name: measurement}
+        values:               {component_name: measurement}
         correction_magnitude: size of the correction being applied
-        alpha:      mixing coefficient for the correction
-        confidences: per-component confidence (defaults to MODERATE)
+        alpha:                mixing coefficient for the correction
+        confidences:          per-component Confidence overrides (defaults to MODERATE)
+        label:                tag for this expression (e.g. step identifier)
+        step:                 step index (set automatically by Monitor)
+        provenance:           provenance tags attached to all observations
         """
         confidences = confidences or {}
         provenance = provenance or []

{margin-0.9.6 → margin-0.9.8}/margin/policy/validate.py

@@ -82,6 +82,10 @@ def validate(
     5. Missing health coverage (no rule handles ABLATED, DEGRADED, etc.)
     6. Contract coverage (if a contract is provided, check that the
        policy has rules for every component the contract mentions)
+    7. Component coverage (if components list provided)
+    8. alpha_from_sigma without a constraint floor
+    9. min_confidence too high (Parser.parse() defaults to MODERATE, so
+       rules with min_confidence >= HIGH may silently never fire)
 
     Args:
         policy:     the policy to validate
@@ -146,6 +150,9 @@ def validate(
     # 8. alpha_from_sigma without a constraint floor
     _check_alpha_from_sigma(policy, issues)
 
+    # 9. min_confidence gate too high for default parse behaviour
+    _check_min_confidence(policy, issues)
+
     return ValidationResult(issues=issues)
 
 
@@ -256,3 +263,22 @@ def _check_component_coverage(
             issues.append(ValidationIssue(
                 "info", "policy",
                 f"component '{comp}' has no dedicated rule (no wildcard rules either)"))
+
+
+def _check_min_confidence(policy: Policy, issues: list[ValidationIssue]) -> None:
+    """
+    Warn when a rule's min_confidence gate is above MODERATE.
+
+    Parser.parse() assigns MODERATE confidence to every observation by
+    default (when no per-component confidences dict is passed). A rule
+    with min_confidence >= HIGH will therefore silently never fire unless
+    the caller explicitly passes HIGH or CERTAIN confidences on every step.
+    """
+    for rule in policy.rules:
+        if rule.min_confidence >= Confidence.HIGH:
+            issues.append(ValidationIssue(
+                "warning", rule.name,
+                f"min_confidence={rule.min_confidence.value} — Parser.parse() defaults "
+                "to MODERATE; this rule will never fire unless the caller explicitly "
+                "passes per-component confidences of HIGH or CERTAIN",
+            ))

{margin-0.9.6 → margin-0.9.8}/margin/streaming.py

@@ -392,6 +392,21 @@ class Monitor:
         anomaly_min_reference: int = 10,
         features: Optional[set] = None,
     ):
+        """
+        Args:
+            parser:               Parser configured with baselines and thresholds
+            window:               base window size for all trackers (overridden per-tracker)
+            drift_window:         DriftTracker window (overrides ``window``)
+            anomaly_window:       AnomalyTracker window (overrides ``window``)
+            correlation_window:   CorrelationTracker window (overrides ``window``)
+            window_config:        WindowConfig dataclass; overrides named window params
+            min_correlation:      minimum |r| to include a pair in correlations
+            anomaly_min_reference: minimum steps before AnomalyTracker classifies
+            features:             set of tracker names to enable — ``{"drift"``,
+                                  ``"anomaly"``, ``"correlation"}``; ``None`` (default)
+                                  enables all three; ``set()`` disables all.
+                                  ``"health"`` is always implied and need not be listed.
+        """
         self.parser = parser
         self.window = window
 

{margin-0.9.6 → margin-0.9.8/margin.egg-info}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "margin"
-version = "0.9.6"
+version = "0.9.8"
 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.6 → margin-0.9.8}/tests/test_config.py

@@ -244,3 +244,59 @@ class TestConfigConstraintEscalation:
         }
         result = from_config(cfg)
         assert isinstance(result["contract"].terms[0], HealthTarget)
+
+
+class TestConfigNewFields:
+    def test_alpha_from_sigma_in_config(self):
+        from margin import from_config
+        cfg = {
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "policy": [{
+                "name": "dynamic",
+                "when": "any_degraded",
+                "action": {"op": "RESTORE", "alpha_from_sigma": True},
+            }],
+        }
+        result = from_config(cfg)
+        assert result["policy"].rules[0].action.alpha_from_sigma is True
+
+    def test_min_confidence_in_config(self):
+        from margin import from_config
+        from margin.confidence import Confidence
+        cfg = {
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "policy": [{
+                "name": "high-conf-only",
+                "when": "any_degraded",
+                "action": {"op": "RESTORE", "alpha": 0.5},
+                "min_confidence": "high",
+            }],
+        }
+        result = from_config(cfg)
+        assert result["policy"].rules[0].min_confidence == Confidence.HIGH
+
+    def test_multi_rule_in_config(self):
+        from margin import from_config
+        cfg = {
+            "name": "my-policy",
+            "multi_rule": True,
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "policy": [{"name": "r", "when": "any_degraded", "action": {"op": "RESTORE"}}],
+        }
+        result = from_config(cfg)
+        assert result["policy"].multi_rule is True
+
+    def test_labels_in_config(self):
+        from margin import from_config
+        cfg = {
+            "components": {
+                "cpu": {
+                    "baseline": 50.0, "intact": 40.0, "ablated": 10.0,
+                    "labels": {"ABLATED": "CRITICAL", "INTACT": "OK"},
+                }
+            },
+        }
+        result = from_config(cfg)
+        from margin.health import Health
+        assert result["parser"].label_for("cpu", Health.ABLATED) == "CRITICAL"
+        assert result["parser"].label_for("cpu", Health.INTACT) == "OK"

{margin-0.9.6 → margin-0.9.8}/tests/test_contract.py

@@ -272,3 +272,24 @@ class TestContractTermFromDict:
         from margin import contract_term_from_dict
         with pytest.raises(ValueError, match="Unknown"):
             contract_term_from_dict({"type": "nonexistent", "name": "x"})
+
+
+class TestContractFromDict:
+    def test_roundtrip(self):
+        from margin import Contract, SustainHealth, HealthTarget
+        c = Contract(name="my-contract", terms=[
+            HealthTarget(name="h", component="cpu", target=Health.INTACT),
+            SustainHealth(name="s", component="cpu", target=Health.INTACT, for_steps=5),
+        ])
+        c2 = Contract.from_dict(c.to_dict())
+        assert c2.name == "my-contract"
+        assert len(c2.terms) == 2
+        assert isinstance(c2.terms[0], HealthTarget)
+        assert isinstance(c2.terms[1], SustainHealth)
+
+    def test_empty_contract_roundtrip(self):
+        from margin import Contract
+        c = Contract(name="empty")
+        c2 = Contract.from_dict(c.to_dict())
+        assert c2.name == "empty"
+        assert c2.terms == []

{margin-0.9.6 → margin-0.9.8}/tests/test_ledger.py

@@ -197,3 +197,27 @@ class TestLedgerRoundtrip:
         assert lr.records[0].op == Op.RESTORE
         assert lr.records[1].after is None
         assert lr.render() == ledger.render()
+
+
+class TestLedgerToDict:
+    def test_to_dict_roundtrip(self):
+        from margin.ledger import Ledger, Record
+        from margin.observation import Observation, Op
+        from margin.health import Health
+        from margin.confidence import Confidence
+
+        obs = Observation("cpu", Health.DEGRADED, 30.0, 50.0, Confidence.HIGH)
+        rec = Record(step=0, tag="s0", before=obs, fired=False, op=Op.NOOP, alpha=0.0)
+        ledger = Ledger(label="test", records=[rec])
+        d = ledger.to_dict()
+        assert d["label"] == "test"
+        assert len(d["records"]) == 1
+        ledger2 = Ledger.from_dict(d)
+        assert ledger2.label == "test"
+        assert len(ledger2.records) == 1
+
+    def test_to_json_uses_to_dict(self):
+        import json
+        from margin.ledger import Ledger
+        ledger = Ledger(label="x")
+        assert json.loads(ledger.to_json())["label"] == "x"

{margin-0.9.6 → margin-0.9.8}/tests/test_policy_validate.py

@@ -151,6 +151,44 @@ class TestComponentCoverage:
         assert len(comp_issues) == 0
 
 
+class TestMinConfidenceCheck:
+    def test_high_confidence_gate_warns(self):
+        rule = PolicyRule(
+            "r", any_degraded(),
+            Action(target="*", op=Op.RESTORE, alpha=0.5),
+            min_confidence=Confidence.HIGH,
+        )
+        result = validate(Policy(name="p", rules=[rule]))
+        assert any("min_confidence" in i.message or "MODERATE" in i.message
+                   for i in result.warnings)
+
+    def test_certain_confidence_gate_warns(self):
+        rule = PolicyRule(
+            "r", any_degraded(),
+            Action(target="*", op=Op.RESTORE, alpha=0.5),
+            min_confidence=Confidence.CERTAIN,
+        )
+        result = validate(Policy(name="p", rules=[rule]))
+        assert any("min_confidence" in i.message or "MODERATE" in i.message
+                   for i in result.warnings)
+
+    def test_moderate_confidence_gate_no_warn(self):
+        rule = PolicyRule(
+            "r", any_degraded(),
+            Action(target="*", op=Op.RESTORE, alpha=0.5),
+            min_confidence=Confidence.MODERATE,
+        )
+        result = validate(Policy(name="p", rules=[rule]))
+        # No warning about min_confidence for MODERATE (default parse behaviour)
+        assert not any("MODERATE" in i.message and "min_confidence" in i.message
+                       for i in result.warnings)
+
+    def test_low_confidence_gate_no_warn(self):
+        rule = _make_rule("r", any_degraded())  # default min_confidence=LOW
+        result = validate(Policy(name="p", rules=[rule]))
+        assert not any("min_confidence" in i.message for i in result.warnings)
+
+
 class TestValidationResult:
     def test_valid_when_no_errors(self):
         r = ValidationResult(issues=[])