margin 0.9.22__tar.gz → 0.9.23__tar.gz

{margin-0.9.22/margin.egg-info → margin-0.9.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.22
+Version: 0.9.23
 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.22 → margin-0.9.23}/margin/observation.py

@@ -272,6 +272,10 @@ class Expression:
     def intact(self) -> list[Observation]:
         return [o for o in self.observations if o.health == Health.INTACT]
 
+    def absent(self) -> list[Observation]:
+        """Return observations that represent absent values."""
+        return [o for o in self.observations if o.is_absent]
+
     def to_string(self) -> str:
         """Compact bracket notation."""
         groups: dict[str, dict] = {}
@@ -391,6 +395,7 @@ class Parser:
         label: str = "",
         step: Optional[int] = None,
         provenance: Optional[list[str]] = None,
+        absences: Optional[dict[str, Absence]] = None,
     ) -> Expression:
         """
         Parse a set of component measurements into a typed Expression.
@@ -402,12 +407,20 @@ class Parser:
         label:                tag for this expression (e.g. step identifier)
         step:                 step index (set automatically by Monitor)
         provenance:           provenance tags attached to all observations
+        absences:             {component_name: Absence} — components listed here
+                              get an Observation with health=OOD, value=baseline,
+                              and the typed absence reason.  Components in both
+                              ``values`` and ``absences`` are treated as absent
+                              (absence wins).
         """
         confidences = confidences or {}
         provenance = provenance or []
+        absences = absences or {}
 
         observations = []
         for name, val in values.items():
+            if name in absences:
+                continue  # handled below with the other absences
             if name not in self.baselines:
                 warnings.warn(
                     f"Parser.parse: component {name!r} has no baseline — "
@@ -427,6 +440,19 @@ class Parser:
                 health_label=ct.label_for(h) if ct.labels else None,
             ))
 
+        # Emit absent observations for components listed in absences
+        for name, reason in absences.items():
+            baseline = self.baselines.get(name, 0.0)
+            ct = self._thresholds_for(name)
+            conf = confidences.get(name, Confidence.INDETERMINATE)
+            observations.append(Observation(
+                name=name, health=Health.OOD, value=baseline, baseline=baseline,
+                confidence=conf, higher_is_better=ct.higher_is_better,
+                provenance=list(provenance),
+                health_label=ct.label_for(Health.OOD) if ct.labels else None,
+                absence=reason,
+            ))
+
         corrections = []
         if values:
             target, op = self._classify_op(values, correction_magnitude)

{margin-0.9.22 → margin-0.9.23}/margin/streaming.py

@@ -470,10 +470,15 @@ class Monitor:
         now: Optional[datetime] = None,
         confidences=None,
         provenance=None,
+        absences=None,
     ) -> Expression:
         """
         Process new measurements: classify health, update drift, check anomalies.
 
+        absences: optional {component: Absence} for components that could not
+                  be measured this step.  Absent observations are included in
+                  the Expression but skipped in drift/anomaly trackers.
+
         Returns the current Expression.
         """
         now = now or datetime.now()
@@ -489,6 +494,7 @@ class Monitor:
         self._expression = self.parser.parse(
             values, label=label, step=self._step,
             confidences=confidences, provenance=provenance,
+            absences=absences,
         )
         self._step += 1
 

{margin-0.9.22 → margin-0.9.23/margin.egg-info}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "margin"
-version = "0.9.22"
+version = "0.9.23"
 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.22 → margin-0.9.23}/tests/test_absence.py

@@ -171,6 +171,30 @@ class TestExpressionWithAbsence:
         expr = Expression(observations=[obs])
         assert expr.degraded() == []
 
+    def test_absent_helper(self):
+        obs_present = _obs(name="temp", value=22.0)
+        obs_absent = _obs(name="co2", absence=Absence.SENSOR_FAILED)
+        expr = Expression(observations=[obs_present, obs_absent])
+        result = expr.absent()
+        assert len(result) == 1
+        assert result[0].name == "co2"
+        assert result[0].absence is Absence.SENSOR_FAILED
+
+    def test_absent_empty_when_all_present(self):
+        obs = _obs(name="temp", value=22.0)
+        expr = Expression(observations=[obs])
+        assert expr.absent() == []
+
+    def test_absent_multiple(self):
+        obs1 = _obs(name="co2", absence=Absence.SENSOR_FAILED)
+        obs2 = _obs(name="ph", absence=Absence.BELOW_DETECTION)
+        obs3 = _obs(name="temp", value=22.0)
+        expr = Expression(observations=[obs1, obs2, obs3])
+        result = expr.absent()
+        assert len(result) == 2
+        names = {o.name for o in result}
+        assert names == {"co2", "ph"}
+
 
 # ---------------------------------------------------------------------------
 # Monitor skips absent observations in trackers
@@ -184,53 +208,178 @@ class TestMonitorAbsenceSkip:
         )
         return Monitor(parser, window=50)
 
-    def test_absent_obs_not_in_drift_window(self):
-        """Absent observations should not enter the drift tracker."""
+    def test_normal_flow_unaffected(self):
+        """Standard update flow still works — no regression from the guard."""
         m = self._make_monitor()
-        # Feed 10 normal updates
-        for _ in range(10):
-            m.update({"co2": 400.0, "temp": 22.0})
-        drift_n_before = m._drift_trackers["co2"].n_observations
-
-        # Now manually inject an absent observation into the expression
-        # by constructing one and passing it through update flow.
-        # The simplest way: feed a normal update, then check count.
-        m.update({"co2": 400.0, "temp": 22.0})
-        drift_n_after = m._drift_trackers["co2"].n_observations
-        assert drift_n_after == drift_n_before + 1  # normal obs counted
-
-    def test_absent_obs_excluded_from_drift(self):
-        """
-        When an observation has absence set, Monitor.update() should skip it
-        in drift/anomaly trackers.
-        """
+        for i in range(20):
+            expr = m.update({"co2": 400.0 + i, "temp": 22.0})
+        assert m._drift_trackers["co2"].n_observations == 20
+        assert m._drift_trackers["temp"].n_observations == 20
+        assert expr is not None
+
+    def test_absent_skipped_in_drift_tracker(self):
+        """Absent observations via absences= should not enter drift tracker."""
         m = self._make_monitor()
-        # Feed some normal data
         for _ in range(5):
             m.update({"co2": 400.0, "temp": 22.0})
         n_before = m._drift_trackers["co2"].n_observations
 
-        # Manually set absence on the expression's observations after parse.
-        # This simulates the downstream use case where a caller marks an
-        # observation as absent before it reaches trackers.
-        # Since Parser.parse() never sets absence, we test the guard by
-        # constructing the observation directly and checking the skip path.
-        from margin.observation import Absence as _Absence
-        obs_absent = Observation(
-            name="co2", health=Health.INTACT, value=0.0, baseline=400.0,
-            confidence=Confidence.HIGH, absence=_Absence.SENSOR_FAILED,
+        # co2 absent this step — drift tracker should not advance
+        m.update({"temp": 22.0}, absences={"co2": Absence.SENSOR_FAILED})
+        assert m._drift_trackers["co2"].n_observations == n_before
+        # temp still counted
+        assert m._drift_trackers["temp"].n_observations == 6
+
+    def test_absent_skipped_in_anomaly_tracker(self):
+        """Absent observations should not enter anomaly tracker."""
+        m = self._make_monitor()
+        for _ in range(5):
+            m.update({"co2": 400.0, "temp": 22.0})
+        n_before = m._anomaly_trackers["co2"].n_values
+
+        m.update({"temp": 22.0}, absences={"co2": Absence.NOT_MEASURED})
+        assert m._anomaly_trackers["co2"].n_values == n_before
+
+    def test_absent_appears_in_expression(self):
+        """Even though skipped in trackers, absent obs is in the Expression."""
+        m = self._make_monitor()
+        expr = m.update(
+            {"temp": 22.0},
+            absences={"co2": Absence.SENSOR_FAILED},
         )
-        # Verify is_absent works
-        assert obs_absent.is_absent is True
-        # The guard in Monitor.update() checks obs.is_absent — we've verified
-        # the field and property work. A full integration test would require
-        # Parser to set absence, which is a future feature.
+        assert len(expr.observations) == 2
+        assert len(expr.absent()) == 1
+        assert expr.absent()[0].name == "co2"
+        assert expr.absent()[0].absence is Absence.SENSOR_FAILED
 
-    def test_normal_flow_unaffected(self):
-        """Standard update flow still works — no regression from the guard."""
+    def test_absent_obs_has_health_ood(self):
+        """Parser emits Health.OOD for absent components."""
         m = self._make_monitor()
-        for i in range(20):
-            expr = m.update({"co2": 400.0 + i, "temp": 22.0})
-        assert m._drift_trackers["co2"].n_observations == 20
-        assert m._drift_trackers["temp"].n_observations == 20
-        assert expr is not None
+        expr = m.update(
+            {"temp": 22.0},
+            absences={"co2": Absence.BELOW_DETECTION},
+        )
+        co2 = [o for o in expr.observations if o.name == "co2"][0]
+        assert co2.health is Health.OOD
+        assert co2.is_absent is True
+
+    def test_mixed_present_and_absent_over_time(self):
+        """co2 comes and goes — drift tracker only counts present steps."""
+        m = self._make_monitor()
+        # 3 present
+        for _ in range(3):
+            m.update({"co2": 400.0, "temp": 22.0})
+        # 2 absent
+        for _ in range(2):
+            m.update({"temp": 22.0}, absences={"co2": Absence.PENDING})
+        # 3 more present
+        for _ in range(3):
+            m.update({"co2": 405.0, "temp": 22.0})
+        assert m._drift_trackers["co2"].n_observations == 6  # 3+3, not 8
+        assert m._drift_trackers["temp"].n_observations == 8
+
+
+# ---------------------------------------------------------------------------
+# Parser.parse() with absences parameter
+# ---------------------------------------------------------------------------
+
+class TestParserAbsences:
+    def _make_parser(self):
+        return Parser(
+            baselines={"co2": 400.0, "temp": 22.0, "ph": 7.0},
+            thresholds=Thresholds(intact=0.8, ablated=0.2),
+        )
+
+    def test_no_absences_unchanged(self):
+        p = self._make_parser()
+        expr = p.parse({"co2": 400.0, "temp": 22.0})
+        assert len(expr.observations) == 2
+        assert all(not o.is_absent for o in expr.observations)
+
+    def test_one_absent_component(self):
+        p = self._make_parser()
+        expr = p.parse(
+            {"temp": 22.0},
+            absences={"co2": Absence.SENSOR_FAILED},
+        )
+        assert len(expr.observations) == 2
+        co2 = [o for o in expr.observations if o.name == "co2"][0]
+        assert co2.is_absent is True
+        assert co2.absence is Absence.SENSOR_FAILED
+        assert co2.health is Health.OOD
+        assert co2.value == 400.0  # baseline used as value
+
+    def test_absent_value_equals_baseline(self):
+        p = self._make_parser()
+        expr = p.parse(
+            {"temp": 22.0},
+            absences={"ph": Absence.BELOW_DETECTION},
+        )
+        ph = [o for o in expr.observations if o.name == "ph"][0]
+        assert ph.value == 7.0  # baseline
+        assert ph.sigma == pytest.approx(0.0)  # value == baseline → sigma 0
+
+    def test_absent_confidence_defaults_to_indeterminate(self):
+        p = self._make_parser()
+        expr = p.parse(
+            {"temp": 22.0},
+            absences={"co2": Absence.NOT_MEASURED},
+        )
+        co2 = [o for o in expr.observations if o.name == "co2"][0]
+        assert co2.confidence is Confidence.INDETERMINATE
+
+    def test_absent_confidence_overridable(self):
+        p = self._make_parser()
+        expr = p.parse(
+            {"temp": 22.0},
+            absences={"co2": Absence.NOT_MEASURED},
+            confidences={"co2": Confidence.LOW},
+        )
+        co2 = [o for o in expr.observations if o.name == "co2"][0]
+        assert co2.confidence is Confidence.LOW
+
+    def test_absence_wins_over_value(self):
+        """If a component appears in both values and absences, absence wins."""
+        p = self._make_parser()
+        expr = p.parse(
+            {"co2": 999.0, "temp": 22.0},
+            absences={"co2": Absence.REDACTED},
+        )
+        co2 = [o for o in expr.observations if o.name == "co2"][0]
+        assert co2.is_absent is True
+        assert co2.value == 400.0  # baseline, not the 999.0 that was passed
+
+    def test_all_absent(self):
+        p = self._make_parser()
+        expr = p.parse(
+            {},
+            absences={
+                "co2": Absence.SENSOR_FAILED,
+                "temp": Absence.NOT_MEASURED,
+            },
+        )
+        assert len(expr.observations) == 2
+        assert all(o.is_absent for o in expr.observations)
+
+    def test_absent_unknown_component(self):
+        """Absent component not in baselines still emits an observation."""
+        p = self._make_parser()
+        expr = p.parse(
+            {"temp": 22.0},
+            absences={"humidity": Absence.NOT_APPLICABLE},
+        )
+        hum = [o for o in expr.observations if o.name == "humidity"][0]
+        assert hum.is_absent is True
+        assert hum.value == 0.0  # no baseline → 0.0
+
+    def test_round_trip_absent_observation(self):
+        p = self._make_parser()
+        expr = p.parse(
+            {"temp": 22.0},
+            absences={"co2": Absence.BELOW_DETECTION},
+        )
+        d = expr.to_dict()
+        restored = Expression.from_dict(d)
+        co2 = [o for o in restored.observations if o.name == "co2"][0]
+        assert co2.absence is Absence.BELOW_DETECTION
+        assert co2.is_absent is True