margin 0.9.9__tar.gz → 0.9.11__tar.gz

{margin-0.9.9/margin.egg-info → margin-0.9.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.9
+Version: 0.9.11
 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.9 → margin-0.9.11}/margin/drift.py

@@ -71,6 +71,12 @@ class DriftClassification:
     n_samples: int
     window_seconds: float
 
+    @property
+    def step_count(self) -> int:
+        """Number of observations that contributed to this classification.
+        A 3-step OSCILLATING is noise; a 20-step OSCILLATING is real."""
+        return self.n_samples
+
     @property
     def stable(self) -> bool:
         return self.state == DriftState.STABLE

{margin-0.9.9 → margin-0.9.11}/margin/events.py

@@ -1,8 +1,22 @@
 """
 Event bus for validity invalidation.
 
-Wires Validity.until_event() to actual event dispatch. When an event
-fires, all values whose Validity references that event become stale.
+Standalone utility — not wired into Monitor or the evaluation loop.
+Use directly in event-driven systems where values should become stale
+when something changes (config reload, model update, deployment).
+
+    bus = EventBus()
+    bus.fire("config_reload")
+
+    v = Validity.until_event("config_reload")
+    bus.is_valid(v)  # False — invalidated
+
+    bus.on("deploy", lambda evt, ts: print(f"deployed at {ts}"))
+
+When an event fires, all Validity descriptors that reference it via
+Validity.until_event() become stale. bus.is_valid() / bus.is_value_valid()
+check this. EventBus does NOT integrate with Monitor health transitions;
+for that use case, attach a listener to Monitor.update() manually.
 """
 
 from __future__ import annotations

{margin-0.9.9 → margin-0.9.11}/margin/observation.py

@@ -320,6 +320,31 @@ class Parser:
         """Return the display label for a component's health state."""
         return self._thresholds_for(component).label_for(health)
 
+    def with_baselines(self, fingerprint: dict[str, dict]) -> 'Parser':
+        """
+        Return a new Parser with baselines updated from a fingerprint dict.
+
+        Components present in ``fingerprint`` get their baseline replaced with
+        ``fingerprint[name]["mean"]``. All other components and all thresholds
+        are preserved unchanged.
+
+        Typical use: dispositional calibration from ``Monitor.fingerprint()``
+        at a session boundary, without full Parser reconstruction.
+
+            fp = monitor.fingerprint()
+            new_parser = monitor.parser.with_baselines(fp)
+            # new_parser has empirical session means as baselines
+        """
+        new_baselines = dict(self.baselines)
+        for name, stats in fingerprint.items():
+            if name in new_baselines and "mean" in stats:
+                new_baselines[name] = stats["mean"]
+        return Parser(
+            baselines=new_baselines,
+            thresholds=self.thresholds,
+            component_thresholds=dict(self.component_thresholds),
+        )
+
     def parse(
         self,
         values: dict[str, float],

{margin-0.9.9 → margin-0.9.11}/margin/persist.py

@@ -17,6 +17,7 @@ from pathlib import Path
 from typing import Optional
 
 from .observation import Observation, Expression, Parser
+from .provenance import ProvenanceGraph
 from .streaming import Monitor, DriftTracker, AnomalyTracker, CorrelationTracker
 
 
@@ -41,6 +42,8 @@ def save_monitor(monitor: Monitor, path: str) -> None:
             "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,
+        "provenance_graph": monitor.provenance_graph.to_dict()
+            if monitor.provenance_graph is not None else None,
     }
 
     for name, dt in monitor._drift_trackers.items():
@@ -56,14 +59,19 @@ def save_monitor(monitor: Monitor, path: str) -> None:
     Path(path).write_text(json.dumps(state, indent=2))
 
 
-def load_monitor(path: str, parser: Parser, **kwargs) -> Monitor:
+def load_monitor(path: str, parser: Parser, warm_only: bool = False, **kwargs) -> Monitor:
     """
     Restore a Monitor from a saved state file.
 
     Args:
-        path:    path to the state JSON
-        parser:  the Parser to use (must match the saved components)
-        **kwargs: passed to Monitor constructor (window, min_correlation, etc.)
+        path:      path to the state JSON
+        parser:    the Parser to use (must match the saved components)
+        warm_only: if True, load drift observations only — anomaly and
+                   correlation trackers start fresh and step count resets
+                   to 0. Use this when starting a new session that should
+                   inherit drift trajectory (warm prior) but not anomaly
+                   reference windows or correlation history.
+        **kwargs:  passed to Monitor constructor (window, min_correlation, etc.)
     """
     data = json.loads(Path(path).read_text())
 
@@ -83,7 +91,12 @@ def load_monitor(path: str, parser: Parser, **kwargs) -> Monitor:
         features=features,
         **kwargs,
     )
-    monitor._step = data.get("step", 0)
+    monitor._step = 0 if warm_only else data.get("step", 0)
+
+    # Restore provenance graph if present
+    pg_data = data.get("provenance_graph")
+    if pg_data is not None:
+        monitor.provenance_graph = ProvenanceGraph.from_dict(pg_data)
 
     # Restore drift tracker observations
     for name, dt_data in data.get("drift", {}).items():
@@ -97,21 +110,22 @@ def load_monitor(path: str, parser: Parser, **kwargs) -> Monitor:
                 from .drift import classify_drift
                 tracker._classification = classify_drift(list(tracker._observations))
 
-    # Restore anomaly tracker values
-    for name, at_data in data.get("anomaly", {}).items():
-        if name in monitor._anomaly_trackers:
-            tracker = monitor._anomaly_trackers[name]
-            for v in at_data.get("values", []):
-                tracker._values.append(v)
-
-    # Restore correlation series
-    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)
+    # Restore anomaly tracker values (skipped in warm_only mode)
+    if not warm_only:
+        for name, at_data in data.get("anomaly", {}).items():
+            if name in monitor._anomaly_trackers:
+                tracker = monitor._anomaly_trackers[name]
+                for v in at_data.get("values", []):
+                    tracker._values.append(v)
+
+        # Restore correlation series (skipped in warm_only mode)
+        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.9 → margin-0.9.11}/margin/provenance.py

@@ -111,6 +111,30 @@ class ProvenanceGraph:
         self.add_node(ProvenanceNode(id=node_id, operation=operation, source_ids=source_ids))
         return node_id
 
+    def compress(self, max_nodes: int = 500) -> 'ProvenanceGraph':
+        """
+        Prune the oldest nodes to stay within max_nodes.
+
+        Nodes are removed in insertion order (oldest first). Any
+        ``source_ids`` in surviving nodes that reference a pruned node
+        are removed, so the graph stays self-consistent — survivors
+        whose parents were pruned become new roots.
+
+        Returns self for chaining (e.g. before save_monitor).
+
+            monitor.provenance_graph.compress(500)
+            save_monitor(monitor, "state.json")
+        """
+        if len(self.nodes) <= max_nodes:
+            return self
+        all_ids = list(self.nodes.keys())
+        pruned = set(all_ids[:-max_nodes])
+        for node_id in pruned:
+            del self.nodes[node_id]
+        for node in self.nodes.values():
+            node.source_ids = [sid for sid in node.source_ids if sid not in pruned]
+        return self
+
     def to_dict(self) -> dict:
         return {"nodes": {k: v.to_dict() for k, v in self.nodes.items()}}
 

{margin-0.9.9 → margin-0.9.11}/margin/streaming.py

@@ -63,6 +63,7 @@ class WindowConfig:
 from .confidence import Confidence
 from .health import Health, Thresholds, classify
 from .observation import Observation, Expression
+from .provenance import ProvenanceGraph
 from .drift import (
     DriftState, DriftDirection, DriftClassification,
     classify_drift,
@@ -391,6 +392,7 @@ class Monitor:
         min_correlation: float = 0.7,
         anomaly_min_reference: int = 10,
         features: Optional[set] = None,
+        provenance_graph: Optional[ProvenanceGraph] = None,
     ):
         """
         Args:
@@ -406,6 +408,11 @@ class Monitor:
                                   ``"anomaly"``, ``"correlation"}``; ``None`` (default)
                                   enables all three; ``set()`` disables all.
                                   ``"health"`` is always implied and need not be listed.
+            provenance_graph:     optional ProvenanceGraph; when provided, each
+                                  ``update()`` call records a root node
+                                  (``"monitor:step:N"``) and threads its ID into
+                                  every observation's ``provenance`` list, enabling
+                                  full lineage queries via ``monitor.provenance_graph``
         """
         self.parser = parser
         self.window = window
@@ -428,6 +435,7 @@ class Monitor:
                 stacklevel=2,
             )
 
+        self.provenance_graph: Optional[ProvenanceGraph] = provenance_graph
         self._expression: Optional[Expression] = None
         self._step = 0
 
@@ -469,6 +477,13 @@ class Monitor:
         """
         now = now or datetime.now()
 
+        # Record a step root in the provenance graph if one is attached.
+        # The step ID is prepended to any caller-supplied provenance tags so
+        # every observation carries both the step origin and the user context.
+        if self.provenance_graph is not None:
+            step_id = self.provenance_graph.create_root(f"monitor:step:{self._step}")
+            provenance = [step_id] + list(provenance or [])
+
         # Health classification via Parser
         self._expression = self.parser.parse(
             values, label=label, step=self._step,
@@ -546,8 +561,48 @@ class Monitor:
                     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()
+        if self.provenance_graph is not None:
+            d["provenance_nodes"] = len(self.provenance_graph.nodes)
         return d
 
+    def fingerprint(self) -> dict[str, dict]:
+        """
+        Session statistics for each component from the current drift window.
+
+        Returns ``{name: {mean, std, n, trend}}`` where:
+
+        - ``mean``  — empirical mean of values in the window
+        - ``std``   — sample standard deviation (0.0 if n < 2)
+        - ``n``     — number of observations currently in the window
+        - ``trend`` — DriftState value string, or ``"UNKNOWN"`` if < min_samples
+
+        Typical use: dispositional calibration before a session boundary.
+
+            fp = monitor.fingerprint()
+            new_parser = monitor.parser.with_baselines(fp)
+        """
+        result: dict[str, dict] = {}
+        for name, tracker in self._drift_trackers.items():
+            obs = list(tracker._observations)
+            n = len(obs)
+            if n == 0:
+                result[name] = {
+                    "mean": self.parser.baselines.get(name, 0.0),
+                    "std": 0.0, "n": 0, "trend": "UNKNOWN",
+                }
+                continue
+            values = [o.value for o in obs]
+            mean = sum(values) / n
+            std = (sum((v - mean) ** 2 for v in values) / (n - 1)) ** 0.5 if n >= 2 else 0.0
+            dc = tracker.classification
+            result[name] = {
+                "mean": mean,
+                "std": std,
+                "n": n,
+                "trend": dc.state.value if dc is not None else "UNKNOWN",
+            }
+        return result
+
     def reset_anomaly_reference(self, components: Optional[list[str]] = None) -> None:
         """
         Clear AnomalyTracker reference windows for the specified components.
@@ -586,4 +641,5 @@ class Monitor:
             feat = ""
         else:
             feat = f", features={{{', '.join(sorted(self.features))}}}"
-        return f"Monitor(step={self._step}, {len(self._drift_trackers)} components, {w}{feat})"
+        pg = ", provenance=True" if self.provenance_graph is not None else ""
+        return f"Monitor(step={self._step}, {len(self._drift_trackers)} components, {w}{feat}{pg})"

{margin-0.9.9 → margin-0.9.11/margin.egg-info}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "margin"
-version = "0.9.9"
+version = "0.9.11"
 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.9 → margin-0.9.11}/tests/test_drift.py

@@ -497,3 +497,18 @@ class TestDriftForecast:
         assert df.drift.state == DriftState.STABLE
         # No ETA in summary for stable
         assert "ETA" not in df.summary
+
+
+class TestDriftClassificationStepCount:
+    def test_step_count_equals_n_samples(self):
+        from margin.drift import DriftClassification, DriftState, DriftDirection
+        from margin.confidence import Confidence
+        dc = DriftClassification(
+            component="cpu", state=DriftState.STABLE,
+            direction=DriftDirection.NEUTRAL, rate=0.0,
+            acceleration=0.0, r_squared=0.9,
+            confidence=Confidence.HIGH, n_samples=17,
+            window_seconds=120.0,
+        )
+        assert dc.step_count == 17
+        assert dc.step_count == dc.n_samples

{margin-0.9.9 → margin-0.9.11}/tests/test_persist.py

@@ -10,6 +10,7 @@ from margin import (
     save_monitor, load_monitor, replay, replay_csv,
     DriftState, AnomalyState,
 )
+from margin.provenance import ProvenanceGraph
 
 
 def _parser():
@@ -264,3 +265,90 @@ class TestFeaturesRoundtrip:
 
         assert data["anomaly_min_reference"] == 25
         assert m2._anomaly_trackers["cpu"]._min_reference == 25
+
+
+class TestProvenanceGraphRoundtrip:
+    def test_provenance_graph_saved_and_restored(self):
+        p = _parser()
+        pg = ProvenanceGraph()
+        m = Monitor(p, provenance_graph=pg)
+        for i in range(3):
+            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 m2.provenance_graph is not None
+        assert len(m2.provenance_graph.nodes) == 3
+
+    def test_no_provenance_graph_not_saved(self):
+        p = _parser()
+        m = Monitor(p)
+        m.update({"cpu": 50.0, "mem": 70.0}, now=t0)
+
+        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.get("provenance_graph") is None
+        assert m2.provenance_graph is None
+
+
+class TestLoadMonitorWarmOnly:
+    def test_warm_only_resets_step(self):
+        p = _parser()
+        m = Monitor(p)
+        for i in range(20):
+            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, warm_only=True)
+            Path(f.name).unlink()
+
+        assert m2.step == 0  # fresh session
+
+    def test_warm_only_keeps_drift_observations(self):
+        p = _parser()
+        m = Monitor(p)
+        for i in range(20):
+            m.update({"cpu": 50.0 - i * 0.5, "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, warm_only=True)
+            Path(f.name).unlink()
+
+        assert m2._drift_trackers["cpu"].n_observations > 0
+
+    def test_warm_only_clears_anomaly(self):
+        p = _parser()
+        m = Monitor(p)
+        for i in range(20):
+            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, warm_only=True)
+            Path(f.name).unlink()
+
+        assert all(t._values == [] or len(t._values) == 0
+                   for t in m2._anomaly_trackers.values())
+
+    def test_warm_only_false_restores_everything(self):
+        p = _parser()
+        m = Monitor(p)
+        for i in range(20):
+            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, warm_only=False)
+            Path(f.name).unlink()
+
+        assert m2.step == 20

margin-0.9.11/tests/test_provenance.py

@@ -0,0 +1,84 @@
+from margin.provenance import new_id, are_correlated, merge, ProvenanceGraph
+
+
+class TestNewId:
+    def test_returns_string(self):
+        assert isinstance(new_id(), str)
+
+    def test_unique(self):
+        ids = {new_id() for _ in range(100)}
+        assert len(ids) == 100
+
+    def test_length(self):
+        assert len(new_id()) == 8
+
+
+class TestAreCorrelated:
+    def test_shared_ancestor(self):
+        shared = new_id()
+        assert are_correlated([shared, "a"], [shared, "b"]) is True
+
+    def test_no_shared_ancestor(self):
+        assert are_correlated(["a", "b"], ["c", "d"]) is False
+
+    def test_empty_lists(self):
+        assert are_correlated([], []) is False
+
+    def test_one_empty(self):
+        assert are_correlated(["a"], []) is False
+
+
+class TestMerge:
+    def test_contains_both(self):
+        m = merge(["a"], ["b"])
+        assert "a" in m
+        assert "b" in m
+
+    def test_adds_new_id(self):
+        m = merge(["a"], ["b"])
+        assert len(m) == 3  # a, b, new
+
+    def test_deduplicates(self):
+        m = merge(["a", "b"], ["b", "c"])
+        assert sorted([x for x in m if x in ("a", "b", "c")]) == ["a", "b", "c"]
+
+
+class TestProvenanceGraphCompress:
+    def test_compress_noop_when_under_limit(self):
+        pg = ProvenanceGraph()
+        for _ in range(10):
+            pg.create_root("step")
+        pg.compress(max_nodes=20)
+        assert len(pg.nodes) == 10
+
+    def test_compress_prunes_to_max(self):
+        pg = ProvenanceGraph()
+        for _ in range(100):
+            pg.create_root("step")
+        pg.compress(max_nodes=50)
+        assert len(pg.nodes) == 50
+
+    def test_compress_keeps_newest(self):
+        pg = ProvenanceGraph()
+        ids = [pg.create_root(f"step:{i}") for i in range(10)]
+        pg.compress(max_nodes=5)
+        for node_id in ids[-5:]:
+            assert node_id in pg.nodes
+        for node_id in ids[:5]:
+            assert node_id not in pg.nodes
+
+    def test_compress_cleans_dangling_source_ids(self):
+        pg = ProvenanceGraph()
+        root = pg.create_root("root")
+        child = pg.derive("child", [root])
+        pg.compress(max_nodes=1)  # prune root, keep child
+        assert root not in pg.nodes
+        assert child in pg.nodes
+        assert pg.nodes[child].source_ids == []  # dangling ref removed
+
+    def test_compress_returns_self(self):
+        pg = ProvenanceGraph()
+        for _ in range(10):
+            pg.create_root("step")
+        result = pg.compress(max_nodes=5)
+        assert result is pg

{margin-0.9.9 → margin-0.9.11}/tests/test_streaming.py

@@ -8,6 +8,7 @@ from margin import (
     DriftTracker, AnomalyTracker, CorrelationTracker, Monitor,
     WindowConfig,
 )
+from margin.provenance import ProvenanceGraph
 
 
 t0 = datetime(2026, 1, 1)
@@ -448,3 +449,147 @@ class TestWindowConfigSerialization:
         assert wc.drift is None
         assert wc.anomaly is None
         assert wc.correlation is None
+
+
+class TestMonitorProvenanceGraph:
+    def _parser(self):
+        return Parser({"cpu": 100.0}, Thresholds(intact=80.0, ablated=40.0))
+
+    def test_provenance_graph_off_by_default(self):
+        m = Monitor(self._parser())
+        assert m.provenance_graph is None
+
+    def test_provenance_graph_records_step_nodes(self):
+        pg = ProvenanceGraph()
+        m = Monitor(self._parser(), provenance_graph=pg)
+        m.update({"cpu": 90.0})
+        m.update({"cpu": 85.0})
+        assert len(pg.nodes) == 2
+
+    def test_observations_carry_step_provenance_id(self):
+        pg = ProvenanceGraph()
+        m = Monitor(self._parser(), provenance_graph=pg)
+        expr = m.update({"cpu": 90.0})
+        obs = expr.observations[0]
+        assert len(obs.provenance) == 1
+        assert obs.provenance[0] in pg.nodes
+
+    def test_user_provenance_tags_also_included(self):
+        pg = ProvenanceGraph()
+        m = Monitor(self._parser(), provenance_graph=pg)
+        expr = m.update({"cpu": 90.0}, provenance=["sensor-42"])
+        obs = expr.observations[0]
+        assert "sensor-42" in obs.provenance
+        # also has the step root ID
+        assert any(p in pg.nodes for p in obs.provenance)
+
+    def test_step_node_operation_name(self):
+        pg = ProvenanceGraph()
+        m = Monitor(self._parser(), provenance_graph=pg)
+        m.update({"cpu": 90.0})
+        node = next(iter(pg.nodes.values()))
+        assert node.operation == "monitor:step:0"
+
+    def test_status_includes_provenance_node_count(self):
+        pg = ProvenanceGraph()
+        m = Monitor(self._parser(), provenance_graph=pg)
+        m.update({"cpu": 90.0})
+        s = m.status()
+        assert s["provenance_nodes"] == 1
+
+    def test_status_no_provenance_key_when_none(self):
+        m = Monitor(self._parser())
+        m.update({"cpu": 90.0})
+        assert "provenance_nodes" not in m.status()
+
+    def test_repr_shows_provenance(self):
+        pg = ProvenanceGraph()
+        m = Monitor(self._parser(), provenance_graph=pg)
+        assert "provenance=True" in repr(m)
+
+    def test_repr_no_provenance_marker_when_none(self):
+        m = Monitor(self._parser())
+        assert "provenance" not in repr(m)
+
+    def test_trace_lineage_via_graph(self):
+        pg = ProvenanceGraph()
+        m = Monitor(self._parser(), provenance_graph=pg)
+        expr = m.update({"cpu": 90.0})
+        step_id = expr.observations[0].provenance[0]
+        lineage = pg.trace_lineage(step_id)
+        assert len(lineage) == 1
+        assert lineage[0].id == step_id
+
+
+class TestMonitorFingerprint:
+    def _parser(self):
+        return Parser({"cpu": 100.0, "mem": 80.0}, Thresholds(intact=80.0, ablated=40.0))
+
+    def test_fingerprint_empty_before_updates(self):
+        m = Monitor(self._parser())
+        fp = m.fingerprint()
+        assert set(fp.keys()) == {"cpu", "mem"}
+        assert fp["cpu"]["n"] == 0
+        assert fp["cpu"]["trend"] == "UNKNOWN"
+        assert fp["cpu"]["mean"] == 100.0  # falls back to parser baseline
+
+    def test_fingerprint_mean_and_n(self):
+        m = Monitor(self._parser())
+        for v in [90.0, 95.0, 85.0]:
+            m.update({"cpu": v, "mem": 75.0})
+        fp = m.fingerprint()
+        assert fp["cpu"]["n"] == 3
+        assert abs(fp["cpu"]["mean"] - 90.0) < 0.01
+
+    def test_fingerprint_std(self):
+        m = Monitor(self._parser())
+        for v in [90.0, 90.0, 90.0]:
+            m.update({"cpu": v, "mem": 75.0})
+        fp = m.fingerprint()
+        assert fp["cpu"]["std"] == 0.0
+
+    def test_fingerprint_trend_populated(self):
+        m = Monitor(self._parser())
+        for i in range(10):
+            m.update({"cpu": 90.0 - i * 2, "mem": 75.0})
+        fp = m.fingerprint()
+        assert fp["cpu"]["trend"] in {"STABLE", "DRIFTING", "ACCELERATING",
+                                       "DECELERATING", "REVERTING", "OSCILLATING"}
+
+
+class TestParserWithBaselines:
+    def _parser(self):
+        return Parser(
+            {"cpu": 100.0, "mem": 80.0},
+            Thresholds(intact=80.0, ablated=40.0),
+        )
+
+    def test_updated_baseline(self):
+        p = self._parser()
+        p2 = p.with_baselines({"cpu": {"mean": 92.0, "std": 3.0, "n": 50, "trend": "STABLE"}})
+        assert p2.baselines["cpu"] == 92.0
+        assert p2.baselines["mem"] == 80.0  # unchanged
+
+    def test_unknown_component_ignored(self):
+        p = self._parser()
+        p2 = p.with_baselines({"gpu": {"mean": 70.0}})
+        assert p2.baselines == p.baselines
+
+    def test_thresholds_preserved(self):
+        p = self._parser()
+        p2 = p.with_baselines({"cpu": {"mean": 92.0}})
+        assert p2.thresholds is p.thresholds
+        assert p2.component_thresholds == p.component_thresholds
+
+    def test_original_parser_unchanged(self):
+        p = self._parser()
+        p.with_baselines({"cpu": {"mean": 92.0}})
+        assert p.baselines["cpu"] == 100.0  # original untouched
+
+    def test_fingerprint_roundtrip(self):
+        m = Monitor(self._parser())
+        for v in [88.0, 90.0, 92.0]:
+            m.update({"cpu": v, "mem": 75.0})
+        fp = m.fingerprint()
+        p2 = m.parser.with_baselines(fp)
+        assert abs(p2.baselines["cpu"] - fp["cpu"]["mean"]) < 0.001

margin-0.9.9/tests/test_provenance.py

@@ -1,43 +0,0 @@
-from margin.provenance import new_id, are_correlated, merge
-
-
-class TestNewId:
-    def test_returns_string(self):
-        assert isinstance(new_id(), str)
-
-    def test_unique(self):
-        ids = {new_id() for _ in range(100)}
-        assert len(ids) == 100
-
-    def test_length(self):
-        assert len(new_id()) == 8
-
-
-class TestAreCorrelated:
-    def test_shared_ancestor(self):
-        shared = new_id()
-        assert are_correlated([shared, "a"], [shared, "b"]) is True
-
-    def test_no_shared_ancestor(self):
-        assert are_correlated(["a", "b"], ["c", "d"]) is False
-
-    def test_empty_lists(self):
-        assert are_correlated([], []) is False
-
-    def test_one_empty(self):
-        assert are_correlated(["a"], []) is False
-
-
-class TestMerge:
-    def test_contains_both(self):
-        m = merge(["a"], ["b"])
-        assert "a" in m
-        assert "b" in m
-
-    def test_adds_new_id(self):
-        m = merge(["a"], ["b"])
-        assert len(m) == 3  # a, b, new
-
-    def test_deduplicates(self):
-        m = merge(["a", "b"], ["b", "c"])
-        assert sorted([x for x in m if x in ("a", "b", "c")]) == ["a", "b", "c"]