chanmacro: Signal Expectancy Engine V1 — Market Memory System

Phase A-C complete: 4 core factors, regime detection, signal tracking, Bayesian expectancy. chanmacro/ (32 files, ~4000 lines): - models: 12 enums + 15 Pydantic v2 models (DateAwareModel, MarketStateVector, etc.) - fetchers: OHLCV + Breadth (from data_provider) + Derivatives (new endpoint) - scoring: Price Structure / Breadth (quantile buckets) / OI Matrix (5 discrete states) / Volatility Regime - regime_detector: 3-state (TREND/RANGE/PANIC), factor-locked (Price+Breadth+Vol), versioned, 2-day confirmation - expectancy: SignalTracker (record+outcomes), TimeDecay (half-life=180d), BayesianExpectancyEngine (Empirical Bayes, Leveled, SufficiencyGuard) - validation: FactorValidator (IC/ICIR/Hit Ratio), RegimeValidator (MI/KL/ANOVA), TransitionValidator (stability) - CLI: fetch|score|regime|track|backfill|expectancy|validate|serve - tests: 52 passing (models, scoring, regime, expectancy) data_provider: - /api/derivatives endpoint: funding rate, OI, OI change, basis - _derivatives storage: same persist pattern as K-line (merge→lock→snapshot→atomic write) - background refresh every 60s Co-Authored-By: Claude <noreply@anthropic.com>
2026-06-24 17:44:55 +08:00
parent 34040575c1
commit 71951019fb
43 changed files with 5036 additions and 2 deletions
@@ -0,0 +1,173 @@
+"""Test SignalTracker, TimeDecay, and BayesianExpectancyEngine."""
+import pytest
+from datetime import date, timedelta
+import numpy as np
+
+
+class TestTimeDecay:
+    def test_recent_weight_near_one(self):
+        from expectancy.decay import TimeDecay
+        d = TimeDecay(180)
+        w = d.weight(date(2026, 6, 20), date(2026, 6, 24))
+        assert 0.95 < w < 1.0
+
+    def test_old_weight_decays(self):
+        from expectancy.decay import TimeDecay
+        d = TimeDecay(180)
+        w = d.weight(date(2025, 6, 24), date(2026, 6, 24))
+        assert 0.2 < w < 0.3  # ~365 days at half_life=180
+
+    def test_effective_samples(self):
+        from expectancy.decay import TimeDecay
+        d = TimeDecay(180)
+        dates = [date(2026, 6, 24)] * 10
+        weights = d.weights(dates, date(2026, 6, 24))
+        eff = d.effective_samples(weights)
+        assert eff == pytest.approx(10.0, rel=0.01)
+
+    def test_weighted_win_rate(self):
+        from expectancy.decay import TimeDecay
+        d = TimeDecay(180)
+        wins = np.array([1, 0, 1, 0])
+        weights = np.array([1.0, 1.0, 1.0, 1.0])
+        wr = d.weighted_win_rate(wins, weights)
+        assert wr == 0.5
+
+    def test_weight_at_age(self):
+        from expectancy.decay import TimeDecay
+        w = TimeDecay.weight_at_age(180, 180)
+        assert w == pytest.approx(0.5, rel=0.01)
+
+
+class TestSignalTracker:
+    def test_record_signal(self, db_path, sample_state):
+        from expectancy.tracker import SignalTracker
+        tracker = SignalTracker()
+        rid = tracker.record(
+            date(2026, 3, 15), "B3", 98000.0, sample_state,
+            signal_grade="A", signal_strength=75.0,
+        )
+        assert rid is not None
+        assert rid > 0
+
+    def test_get_samples(self, db_path, sample_state):
+        from expectancy.tracker import SignalTracker
+        tracker = SignalTracker()
+        tracker.record(date(2026, 3, 15), "B3", 98000.0, sample_state)
+        tracker.record(date(2026, 3, 16), "B2", 98500.0, sample_state)
+
+        samples = tracker.get_samples(signal_type="B3")
+        assert len(samples) == 1
+        assert samples[0]["signal_type"] == "B3"
+
+    def test_count_samples(self, db_path, sample_state):
+        from expectancy.tracker import SignalTracker
+        tracker = SignalTracker()
+        tracker.record(date(2026, 3, 15), "B3", 98000.0, sample_state)
+        tracker.record(date(2026, 3, 16), "B3", 98500.0, sample_state)
+
+        counts = tracker.count_samples()
+        assert "B3/TREND" in counts
+        assert counts["B3/TREND"] == 2
+
+    def test_filter_by_regime(self, db_path, sample_state):
+        from expectancy.tracker import SignalTracker
+        tracker = SignalTracker()
+        tracker.record(date(2026, 3, 15), "B3", 98000.0, sample_state)
+
+        samples = tracker.get_samples(signal_type="B3", regime="TREND")
+        assert len(samples) == 1
+
+        samples = tracker.get_samples(signal_type="B3", regime="PANIC")
+        assert len(samples) == 0
+
+    def test_backfill_signals(self, db_path, sample_state):
+        from expectancy.tracker import SignalTracker
+        tracker = SignalTracker()
+        signals = [
+            {"date": date(2026, 3, 15), "signal_type": "B3", "entry_price": 98000},
+            {"date": date(2026, 3, 20), "signal_type": "B2", "entry_price": 99000},
+        ]
+        count = tracker.backfill_signals(signals)
+        assert count == 2
+
+
+class TestBayesianExpectancyEngine:
+    def test_estimate_returns_report(self, db_path, sample_state):
+        from expectancy.tracker import SignalTracker
+        from expectancy.engine import BayesianExpectancyEngine
+
+        # Record some signals first
+        tracker = SignalTracker()
+        for i in range(10):
+            tracker.record(
+                date(2026, 3, 15) + timedelta(days=i),
+                "B3", 98000.0, sample_state,
+            )
+
+        engine = BayesianExpectancyEngine(level_min_samples=3)
+        report = engine.estimate(sample_state, "B3", date(2026, 3, 25))
+        assert report.signal_type == "B3"
+        assert len(report.layers) > 0
+        assert report.source in ("bayesian", "insufficient")
+
+    def test_insufficient_with_no_samples(self, db_path, sample_state):
+        from expectancy.engine import BayesianExpectancyEngine
+        engine = BayesianExpectancyEngine(level_min_samples=10)
+        report = engine.estimate(sample_state, "B1", date(2026, 3, 25))
+        assert report.sufficiency.value in ("INSUFFICIENT", "LOW", "MEDIUM", "HIGH")
+
+    def test_empirical_bayes_shrinks_small_samples(self, db_path, sample_state):
+        """With N=3, raw=100%, posterior should be pulled toward prior."""
+        from expectancy.tracker import SignalTracker
+        from expectancy.engine import BayesianExpectancyEngine
+
+        tracker = SignalTracker()
+        for i in range(3):
+            tracker.record(
+                date(2026, 3, 15) + timedelta(days=i),
+                "B3", 98000.0, sample_state,
+            )
+
+        engine = BayesianExpectancyEngine(level_min_samples=1)
+        report = engine.estimate(sample_state, "B3", date(2026, 3, 25))
+
+        # With small N, posterior should differ from raw
+        base_layer = report.layers[0]
+        if base_layer.raw_winrate and base_layer.samples < 50:
+            # Posterior should be pulled toward prior (50% or global rate)
+            if base_layer.raw_winrate > 0.8:
+                assert base_layer.posterior_winrate < base_layer.raw_winrate
+
+    def test_leveled_fallback_stops_at_min_samples(self, db_path, sample_state):
+        from expectancy.tracker import SignalTracker
+        from expectancy.engine import BayesianExpectancyEngine
+
+        tracker = SignalTracker()
+        for i in range(20):
+            tracker.record(date(2026, 3, 15) + timedelta(days=i), "B3", 98000.0, sample_state)
+
+        engine = BayesianExpectancyEngine(level_min_samples=15)
+        report = engine.estimate(sample_state, "B3", date(2026, 3, 25))
+        # Should have stopped at a level with >= 15 effective samples
+        assert report.final_estimate >= 0
+
+
+class TestSufficiencyGuard:
+    def test_insufficient(self):
+        from expectancy.engine import SufficiencyGuard
+        from models import SufficiencyLevel
+        g = SufficiencyGuard()
+        assert g.evaluate(10) == SufficiencyLevel.INSUFFICIENT
+
+    def test_low(self):
+        from expectancy.engine import SufficiencyGuard
+        from models import SufficiencyLevel
+        g = SufficiencyGuard()
+        assert g.evaluate(40) == SufficiencyLevel.LOW
+
+    def test_high(self):
+        from expectancy.engine import SufficiencyGuard
+        from models import SufficiencyLevel
+        g = SufficiencyGuard()
+        assert g.evaluate(200) == SufficiencyLevel.HIGH