margin 0.9.24__tar.gz → 0.9.26__tar.gz

{margin-0.9.24/margin.egg-info → margin-0.9.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.24
+Version: 0.9.26
 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.24 → margin-0.9.26}/margin/anomaly.py

@@ -243,7 +243,7 @@ def _std(xs: list[float], mean: float) -> float:
 
 def _kurtosis_excess(xs: list[float], mean: float, std: float) -> float:
     """Excess kurtosis (0 for normal distribution)."""
-    if std == 0 or len(xs) < 4:
+    if std < 1e-12 or len(xs) < 4:
         return 0.0
     n = len(xs)
     m4 = sum((x - mean) ** 4 for x in xs) / n
@@ -252,7 +252,7 @@ def _kurtosis_excess(xs: list[float], mean: float, std: float) -> float:
 
 def _skewness(xs: list[float], mean: float, std: float) -> float:
     """Skewness (0 for symmetric distribution)."""
-    if std == 0 or len(xs) < 3:
+    if std < 1e-12 or len(xs) < 3:
         return 0.0
     n = len(xs)
     m3 = sum((x - mean) ** 3 for x in xs) / n
@@ -306,8 +306,9 @@ def classify_anomaly(
     ref_max = max(reference)
     n = len(reference)
 
-    # Z-score
-    if ref_std > 0:
+    # Z-score — 1e-12 tolerance guards against floating-point noise
+    # (e.g. sum([0.1]*20)/20 yields std ≈ 1.4e-17, not exactly 0.0)
+    if ref_std > 1e-12:
         z = (value - ref_mean) / ref_std
     else:
         # All reference values identical — any deviation is novel
@@ -396,16 +397,21 @@ def check_distribution(
     rec_mean = _mean(recent)
     rec_std = _std(recent, rec_mean)
 
-    # Mean shift (relative to reference)
+    # Mean shift (relative to reference).  Tolerances guard against
+    # floating-point noise from all-constant inputs (std can be ~1e-17 on
+    # some Python versions instead of exactly 0.0).
     if abs(ref_mean) > 1e-10:
         mean_shift = abs(rec_mean - ref_mean) / abs(ref_mean)
-    elif ref_std > 0:
+    elif ref_std > 1e-12:
         mean_shift = abs(rec_mean - ref_mean) / ref_std
     else:
         mean_shift = 0.0 if rec_mean == ref_mean else float('inf')
 
-    # Std ratio
-    std_ratio = rec_std / ref_std if ref_std > 0 else (1.0 if rec_std == 0 else float('inf'))
+    # Std ratio — treat near-zero std as effectively zero
+    if ref_std > 1e-12:
+        std_ratio = rec_std / ref_std
+    else:
+        std_ratio = 1.0 if rec_std < 1e-12 else float('inf')
 
     # Shape metrics
     ref_kurt = _kurtosis_excess(reference, ref_mean, ref_std)

{margin-0.9.24 → margin-0.9.26}/margin/calibrate.py

@@ -120,7 +120,9 @@ def calibrate(
     std = math.sqrt(variance)
 
     if use_std:
-        if std == 0:
+        # 1e-12 tolerance catches both true zero and floating-point noise
+        # from all-constant inputs (std ≈ 1.4e-17 on some Python versions)
+        if std < 1e-12:
             raise ValueError(
                 "Cannot use use_std=True with zero-variance data — all values are identical. "
                 "Use fraction mode (use_std=False) instead.")

{margin-0.9.24 → margin-0.9.26}/margin/fingerprint.py

@@ -176,7 +176,10 @@ class Fingerprint(dict):
         stats = self.get(component, {})
         mean = stats.get("mean", 0.0)
         std = stats.get("std", 0.0)
-        if std != 0.0:
+        # Tolerance guard: std accumulated from all-constant values can be 1e-17
+        # on some Python versions (floating-point noise), which would otherwise
+        # amplify the ratio by 15+ orders of magnitude.
+        if std > 1e-12:
             return (value - mean) / std
         if mean == 0.0:
             return value
@@ -199,7 +202,7 @@ class Fingerprint(dict):
         q25 = self.percentile(component, 25)
         q75 = self.percentile(component, 75)
         iqr = q75 - q25
-        if iqr == 0.0:
+        if abs(iqr) < 1e-12:
             return self.sigma(component, value)
         return (value - median) / iqr
 

{margin-0.9.24 → margin-0.9.26}/margin/streaming.py

@@ -795,7 +795,8 @@ class Monitor:
         z_scores = []
         for m in _metrics:
             ref_std = reference_fp.get(m, {}).get("std", 0.0)
-            if ref_std == 0.0:
+            # 1e-12 tolerance: reject floating-point noise from constant windows
+            if ref_std < 1e-12:
                 continue
             cur_mean = current_fp.get(m, {}).get("mean", 0.0)
             ref_mean = reference_fp.get(m, {}).get("mean", 0.0)

{margin-0.9.24 → margin-0.9.26/margin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.24
+Version: 0.9.26
 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.24 → margin-0.9.26}/margin.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ tests/test_diff.py
 tests/test_drift.py
 tests/test_events.py
 tests/test_fingerprint_ext.py
+tests/test_float_tolerance.py
 tests/test_forecast.py
 tests/test_health.py
 tests/test_healthcare.py

{margin-0.9.24 → margin-0.9.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "margin"
-version = "0.9.24"
+version = "0.9.26"
 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.26/tests/test_float_tolerance.py

@@ -0,0 +1,116 @@
+"""
+Regression tests for floating-point tolerance in std-based division.
+
+On Python 3.10, sum([0.1]*20)/20 returns 0.10000000000000002 and the
+resulting std accumulates to ~1.4e-17 instead of exactly 0.0.  Every
+site that divides by std must treat that as effectively zero or it
+amplifies results by 15+ orders of magnitude.
+
+Sites covered:
+    Fingerprint.sigma              (v0.9.25)
+    Fingerprint.robust_sigma       (v0.9.25)
+    anomaly.check_distribution     (v0.9.25)
+    anomaly.classify_anomaly       (v0.9.26)
+    anomaly._kurtosis_excess       (v0.9.26)
+    anomaly._skewness              (v0.9.26)
+    Monitor.anomaly_score          (v0.9.26)
+    calibrate.calibrate (use_std)  (v0.9.26)
+"""
+import math
+import pytest
+
+from margin import (
+    Absence, AnomalyState, Confidence, Fingerprint, Monitor, Parser, Thresholds,
+    calibrate, check_distribution, classify_anomaly,
+)
+
+
+CONSTANT = [0.1] * 20  # sum/n = 0.10000000000000002, std ≈ 1.4e-17 on 3.10
+
+
+def _fp(values: list[float], name: str = "x") -> Fingerprint:
+    n = len(values)
+    mean = sum(values) / n
+    std = math.sqrt(sum((v - mean) ** 2 for v in values) / (n - 1))
+    return Fingerprint(
+        stats={name: {"mean": mean, "std": std, "n": n, "trend": "STABLE"}},
+        values={name: list(values)},
+    )
+
+
+class TestFingerprintSigma:
+    def test_constant_window_does_not_amplify(self):
+        fp = _fp(CONSTANT)
+        # value-mean = 0.05, std accumulated ≈ 1.4e-17 — bogus division would
+        # give ~3.5e15.  Tolerance guard routes to the |mean| branch instead.
+        result = fp.sigma("x", 0.15)
+        assert abs(result) < 100  # bounded by real signal, not FP noise
+
+    def test_constant_window_robust_sigma_does_not_amplify(self):
+        fp = _fp(CONSTANT)
+        result = fp.robust_sigma("x", 0.15)
+        assert abs(result) < 100
+
+
+class TestAnomalyClassifyAnomaly:
+    def test_constant_reference_does_not_saturate(self):
+        # value very close to mean should not classify as NOVEL just because
+        # dividing by 1e-17 produces a "huge" z-score.
+        ac = classify_anomaly(0.15, CONSTANT, component="rr")
+        assert ac is not None
+        # z-score is either 0 (equal-means branch) or inf (zero-std branch),
+        # never a bogus finite value in the 1e15 range.
+        assert ac.z_score == 0 or math.isinf(ac.z_score) or abs(ac.z_score) < 1e6
+
+
+class TestCheckDistribution:
+    def test_both_constant_windows_no_inf_std_ratio(self):
+        ref = [70.0] * 20
+        recent = [70.2] * 10
+        ds = check_distribution(recent, ref)
+        # Pre-fix, std_ratio was inf.  Post-fix, it's 1.0 (both effectively zero-std).
+        assert math.isfinite(ds.std_ratio) or ds.std_ratio == 1.0
+
+    def test_stable_calibration_no_recalibration(self):
+        from margin 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)
+        # Small shifts on constant data must NOT trigger recalibration.
+        assert flags["cpu"] is False
+        assert flags["mem"] is False
+
+
+class TestMonitorAnomalyScore:
+    def test_constant_reference_fp_skips_noise_metrics(self):
+        parser = Parser(baselines={"rr": 0.1}, thresholds=Thresholds(intact=0.8, ablated=0.2))
+        m = Monitor(parser, window=50)
+        for _ in range(20):
+            m.update({"rr": 0.1})
+        ref_fp = m.fingerprint()
+        # Feed slightly different value, score should be small, not 1e15.
+        for _ in range(20):
+            m.update({"rr": 0.11})
+        score = m.anomaly_score(ref_fp)
+        assert math.isfinite(score)
+        assert score < 1e6
+
+
+class TestCalibrateUseStd:
+    def test_constant_input_raises_clear_error(self):
+        # Pre-fix: std = 1.4e-17 passed the `std == 0` check, producing
+        # thresholds that were essentially baseline ± 1e-17 — all values
+        # classified INTACT.  Post-fix: raises the same clear error as true zero.
+        with pytest.raises(ValueError, match="zero-variance"):
+            calibrate(CONSTANT, use_std=True)
+
+
+class TestSkewKurtosis:
+    def test_constant_input_kurtosis_is_zero(self):
+        from margin.anomaly import _kurtosis_excess, _skewness, _mean, _std
+        xs = CONSTANT
+        mean = _mean(xs)
+        std = _std(xs, mean)
+        # Pre-fix these would divide by ~1e-17 and return nonsense.
+        assert _kurtosis_excess(xs, mean, std) == 0.0
+        assert _skewness(xs, mean, std) == 0.0