quantwise 1.2.0 → 1.2.2

package/.claude/skills/theme-detector/scripts/tests/test_heat_calculator.py

@@ -0,0 +1,245 @@
+"""Tests for heat_calculator.py - Theme Heat Score (0-100)"""
+
+import pytest
+from calculators.heat_calculator import (
+    momentum_strength_score,
+    volume_intensity_score,
+    uptrend_signal_score,
+    breadth_signal_score,
+    calculate_theme_heat,
+)
+
+
+# ── momentum_strength_score ──────────────────────────────────────────
+
+class TestMomentumStrengthScore:
+    """sigmoid: 100 / (1 + exp(-0.15 * (abs(wr%) - 5.0)))"""
+
+    def test_zero_return(self):
+        # abs(0) - 5 = -5 => sigmoid(0.75) ≈ 32
+        score = momentum_strength_score(0.0)
+        assert 30 <= score <= 35
+
+    def test_five_percent(self):
+        # abs(5) - 5 = 0 => sigmoid(0) = 50
+        score = momentum_strength_score(5.0)
+        assert score == pytest.approx(50.0, abs=0.1)
+
+    def test_negative_five_percent(self):
+        # abs(-5) - 5 = 0 => 50
+        score = momentum_strength_score(-5.0)
+        assert score == pytest.approx(50.0, abs=0.1)
+
+    def test_fifteen_percent(self):
+        # abs(15) - 5 = 10 => sigmoid(-1.5) ≈ 82
+        score = momentum_strength_score(15.0)
+        assert 80 <= score <= 85
+
+    def test_twenty_percent(self):
+        # abs(20) - 5 = 15 => sigmoid(-2.25) ≈ 90
+        score = momentum_strength_score(20.0)
+        assert 88 <= score <= 92
+
+    def test_negative_twenty_percent(self):
+        score = momentum_strength_score(-20.0)
+        assert 88 <= score <= 92
+
+    def test_returns_float(self):
+        assert isinstance(momentum_strength_score(3.0), float)
+
+
+# ── volume_intensity_score ───────────────────────────────────────────
+
+class TestVolumeIntensityScore:
+    """min(100, max(0, (vol_20d/vol_60d - 0.8) * 250))"""
+
+    def test_ratio_0_8_returns_zero(self):
+        # (0.8 - 0.8) * 250 = 0
+        assert volume_intensity_score(80.0, 100.0) == pytest.approx(0.0)
+
+    def test_ratio_1_0_returns_50(self):
+        # (1.0 - 0.8) * 250 = 50
+        assert volume_intensity_score(100.0, 100.0) == pytest.approx(50.0)
+
+    def test_ratio_1_2_returns_100(self):
+        # (1.2 - 0.8) * 250 = 100
+        assert volume_intensity_score(120.0, 100.0) == pytest.approx(100.0)
+
+    def test_ratio_above_cap_clamped_to_100(self):
+        # (2.0 - 0.8) * 250 = 300 => clamped 100
+        assert volume_intensity_score(200.0, 100.0) == pytest.approx(100.0)
+
+    def test_ratio_below_floor_clamped_to_0(self):
+        # (0.5 - 0.8) * 250 = -75 => clamped 0
+        assert volume_intensity_score(50.0, 100.0) == pytest.approx(0.0)
+
+    def test_none_vol_20d(self):
+        assert volume_intensity_score(None, 100.0) == pytest.approx(50.0)
+
+    def test_none_vol_60d(self):
+        assert volume_intensity_score(100.0, None) == pytest.approx(50.0)
+
+    def test_zero_vol_60d(self):
+        assert volume_intensity_score(100.0, 0.0) == pytest.approx(50.0)
+
+
+# ── uptrend_signal_score ─────────────────────────────────────────────
+
+class TestUptrendSignalScore:
+
+    def _make_sector(self, ratio, ma_10, slope, weight=1.0):
+        return {
+            "sector": "test",
+            "ratio": ratio,
+            "ma_10": ma_10,
+            "slope": slope,
+            "weight": weight,
+        }
+
+    def test_both_positive_gives_80(self):
+        # ratio>ma_10 AND slope>0 => 80
+        data = [self._make_sector(ratio=50, ma_10=40, slope=0.5)]
+        score = uptrend_signal_score(data, is_bearish=False)
+        assert score == pytest.approx(80.0)
+
+    def test_ratio_only_gives_60(self):
+        # ratio>ma_10 but slope<=0 => 60
+        data = [self._make_sector(ratio=50, ma_10=40, slope=-0.1)]
+        score = uptrend_signal_score(data, is_bearish=False)
+        assert score == pytest.approx(60.0)
+
+    def test_slope_only_gives_60(self):
+        # ratio<=ma_10 but slope>0 => 60
+        data = [self._make_sector(ratio=30, ma_10=40, slope=0.5)]
+        score = uptrend_signal_score(data, is_bearish=False)
+        assert score == pytest.approx(60.0)
+
+    def test_neither_gives_20(self):
+        # ratio<=ma_10 AND slope<=0 => 20
+        data = [self._make_sector(ratio=30, ma_10=40, slope=-0.1)]
+        score = uptrend_signal_score(data, is_bearish=False)
+        assert score == pytest.approx(20.0)
+
+    def test_weighted_average(self):
+        # sector A: both positive => 80, weight 2
+        # sector B: neither => 20, weight 1
+        # weighted = (80*2 + 20*1) / 3 = 60
+        data = [
+            self._make_sector(ratio=50, ma_10=40, slope=0.5, weight=2.0),
+            self._make_sector(ratio=30, ma_10=40, slope=-0.1, weight=1.0),
+        ]
+        score = uptrend_signal_score(data, is_bearish=False)
+        assert score == pytest.approx(60.0)
+
+    def test_bearish_inversion(self):
+        # both positive => 80, bearish => 100-80 = 20
+        data = [self._make_sector(ratio=50, ma_10=40, slope=0.5)]
+        score = uptrend_signal_score(data, is_bearish=True)
+        assert score == pytest.approx(20.0)
+
+    def test_empty_list(self):
+        assert uptrend_signal_score([], is_bearish=False) == pytest.approx(50.0)
+
+    def test_equal_ratio_and_ma10(self):
+        # ratio == ma_10 => not > => slope<=0 => 20
+        data = [self._make_sector(ratio=40, ma_10=40, slope=0)]
+        score = uptrend_signal_score(data, is_bearish=False)
+        assert score == pytest.approx(20.0)
+
+
+# ── breadth_signal_score ─────────────────────────────────────────────
+
+class TestBreadthSignalScore:
+
+    def test_zero(self):
+        assert breadth_signal_score(0.0) == pytest.approx(0.0)
+
+    def test_half(self):
+        assert breadth_signal_score(0.5) == pytest.approx(50.0)
+
+    def test_full(self):
+        assert breadth_signal_score(1.0) == pytest.approx(100.0)
+
+    def test_above_one_clamped(self):
+        assert breadth_signal_score(1.5) == pytest.approx(100.0)
+
+    def test_negative_clamped(self):
+        assert breadth_signal_score(-0.3) == pytest.approx(0.0)
+
+    def test_none(self):
+        assert breadth_signal_score(None) == pytest.approx(50.0)
+
+
+# ── calculate_theme_heat ─────────────────────────────────────────────
+
+class TestCalculateThemeHeat:
+
+    def test_weighted_sum(self):
+        # 80*0.40 + 60*0.25 + 70*0.20 + 50*0.15
+        # = 32 + 15 + 14 + 7.5 = 68.5
+        result = calculate_theme_heat(80.0, 60.0, 70.0, 50.0)
+        assert result == pytest.approx(68.5)
+
+    def test_all_100(self):
+        result = calculate_theme_heat(100.0, 100.0, 100.0, 100.0)
+        assert result == pytest.approx(100.0)
+
+    def test_all_zero(self):
+        result = calculate_theme_heat(0.0, 0.0, 0.0, 0.0)
+        assert result == pytest.approx(0.0)
+
+    def test_none_defaults_to_50(self):
+        # All None => 50*0.40 + 50*0.25 + 50*0.20 + 50*0.15 = 50
+        result = calculate_theme_heat(None, None, None, None)
+        assert result == pytest.approx(50.0)
+
+    def test_partial_none(self):
+        # 80*0.40 + 50*0.25 + 50*0.20 + 50*0.15
+        # = 32 + 12.5 + 10 + 7.5 = 62.0
+        result = calculate_theme_heat(80.0, None, None, None)
+        assert result == pytest.approx(62.0)
+
+    def test_clamped_above_100(self):
+        result = calculate_theme_heat(200.0, 200.0, 200.0, 200.0)
+        assert result == 100.0
+
+    def test_clamped_below_0(self):
+        result = calculate_theme_heat(-50.0, -50.0, -50.0, -50.0)
+        assert result == 0.0
+
+    def test_returns_float(self):
+        assert isinstance(calculate_theme_heat(50, 50, 50, 50), float)
+
+
+# ── uptrend_signal_score with None values ────────────────────────────
+
+class TestUptrendSignalNoneValues:
+    """Ensure None values in sector_data don't cause TypeError."""
+
+    def test_none_ma_10(self):
+        """ma_10=None should not crash (treated as 0)."""
+        data = [{"sector": "Tech", "ratio": 0.5, "ma_10": None, "slope": 0.01, "weight": 1.0}]
+        score = uptrend_signal_score(data, is_bearish=False)
+        # ratio(0.5) > ma_10(0) AND slope(0.01) > 0 => 80
+        assert score == pytest.approx(80.0)
+
+    def test_none_slope(self):
+        """slope=None should not crash (treated as 0)."""
+        data = [{"sector": "Tech", "ratio": 0.5, "ma_10": 0.3, "slope": None, "weight": 1.0}]
+        score = uptrend_signal_score(data, is_bearish=False)
+        # ratio(0.5) > ma_10(0.3) but slope(0) not > 0 => 60
+        assert score == pytest.approx(60.0)
+
+    def test_none_ratio(self):
+        """ratio=None should not crash (treated as 0)."""
+        data = [{"sector": "Tech", "ratio": None, "ma_10": 0.3, "slope": 0.01, "weight": 1.0}]
+        score = uptrend_signal_score(data, is_bearish=False)
+        # ratio(0) not > ma_10(0.3) but slope(0.01) > 0 => 60
+        assert score == pytest.approx(60.0)
+
+    def test_all_none(self):
+        """All values None should not crash."""
+        data = [{"sector": "Tech", "ratio": None, "ma_10": None, "slope": None, "weight": 1.0}]
+        score = uptrend_signal_score(data, is_bearish=False)
+        # ratio(0) not > ma_10(0), slope(0) not > 0 => 20
+        assert score == pytest.approx(20.0)

package/.claude/skills/theme-detector/scripts/tests/test_industry_ranker.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+Tests for industry_ranker module.
+
+Covers momentum_strength_score sigmoid, weighted return calculation,
+ranking, direction classification, and top/bottom extraction.
+"""
+
+import math
+
+from calculators.industry_ranker import (
+    TIMEFRAME_WEIGHTS,
+    get_top_bottom_industries,
+    momentum_strength_score,
+    rank_industries,
+)
+
+# ---------------------------------------------------------------------------
+# momentum_strength_score tests
+# ---------------------------------------------------------------------------
+
+
+class TestMomentumStrengthScore:
+    """Test the direction-neutral sigmoid scoring function."""
+
+    def test_zero_return_gives_about_32(self):
+        """abs(0%) -> ~32 (sigmoid at -5.0 midpoint)."""
+        score = momentum_strength_score(0.0)
+        assert 30 <= score <= 34, f"Expected ~32, got {score}"
+
+    def test_five_pct_gives_50(self):
+        """abs(5%) is the midpoint -> exactly 50."""
+        score = momentum_strength_score(5.0)
+        assert abs(score - 50.0) < 0.1, f"Expected 50, got {score}"
+
+    def test_ten_pct_gives_about_68(self):
+        """abs(10%) -> ~68."""
+        score = momentum_strength_score(10.0)
+        assert 66 <= score <= 70, f"Expected ~68, got {score}"
+
+    def test_fifteen_pct_gives_about_82(self):
+        """abs(15%) -> ~82."""
+        score = momentum_strength_score(15.0)
+        assert 80 <= score <= 84, f"Expected ~82, got {score}"
+
+    def test_twenty_pct_gives_about_90(self):
+        """abs(20%) -> ~90."""
+        score = momentum_strength_score(20.0)
+        assert 88 <= score <= 92, f"Expected ~90, got {score}"
+
+    def test_negative_return_same_as_positive(self):
+        """Negative and positive returns with same magnitude give same score."""
+        pos = momentum_strength_score(12.0)
+        neg = momentum_strength_score(-12.0)
+        assert abs(pos - neg) < 0.01
+
+    def test_large_return_caps_near_100(self):
+        """Very large returns approach but don't exceed 100."""
+        score = momentum_strength_score(50.0)
+        assert 99 <= score <= 100
+
+    def test_score_always_between_0_and_100(self):
+        """Score is bounded [0, 100] for any input."""
+        for ret in [-100, -50, -10, 0, 10, 50, 100]:
+            score = momentum_strength_score(ret)
+            assert 0 <= score <= 100, f"Out of bounds for {ret}: {score}"
+
+    def test_monotonically_increasing_with_abs(self):
+        """Higher absolute return -> higher score."""
+        s1 = momentum_strength_score(5.0)
+        s2 = momentum_strength_score(10.0)
+        s3 = momentum_strength_score(20.0)
+        assert s1 < s2 < s3
+
+
+# ---------------------------------------------------------------------------
+# TIMEFRAME_WEIGHTS validation
+# ---------------------------------------------------------------------------
+
+
+class TestTimeframeWeights:
+    """Verify timeframe weights are correct and sum to 1.0."""
+
+    def test_weights_sum_to_one(self):
+        total = sum(TIMEFRAME_WEIGHTS.values())
+        assert abs(total - 1.0) < 0.001
+
+    def test_expected_keys(self):
+        expected = {"perf_1w", "perf_1m", "perf_3m", "perf_6m"}
+        assert set(TIMEFRAME_WEIGHTS.keys()) == expected
+
+    def test_expected_values(self):
+        assert TIMEFRAME_WEIGHTS["perf_1w"] == 0.10
+        assert TIMEFRAME_WEIGHTS["perf_1m"] == 0.25
+        assert TIMEFRAME_WEIGHTS["perf_3m"] == 0.35
+        assert TIMEFRAME_WEIGHTS["perf_6m"] == 0.30
+
+
+# ---------------------------------------------------------------------------
+# rank_industries tests
+# ---------------------------------------------------------------------------
+
+
+def _make_industry(name, perf_1w=0.0, perf_1m=0.0, perf_3m=0.0, perf_6m=0.0):
+    """Helper to build a synthetic industry dict."""
+    return {
+        "name": name,
+        "perf_1w": perf_1w,
+        "perf_1m": perf_1m,
+        "perf_3m": perf_3m,
+        "perf_6m": perf_6m,
+    }
+
+
+class TestRankIndustries:
+    """Test rank_industries function."""
+
+    def test_adds_required_fields(self):
+        """Each result dict gets momentum_score, weighted_return, direction, rank."""
+        industries = [_make_industry("Tech", 5, 10, 15, 20)]
+        ranked = rank_industries(industries)
+        assert len(ranked) == 1
+        item = ranked[0]
+        assert "momentum_score" in item
+        assert "weighted_return" in item
+        assert "direction" in item
+        assert "rank" in item
+
+    def test_weighted_return_calculation(self):
+        """Verify weighted return = sum(perf_x * weight_x)."""
+        ind = _make_industry("Test", perf_1w=10.0, perf_1m=20.0, perf_3m=30.0, perf_6m=40.0)
+        ranked = rank_industries([ind])
+        expected = 10 * 0.10 + 20 * 0.25 + 30 * 0.35 + 40 * 0.30
+        assert abs(ranked[0]["weighted_return"] - expected) < 0.01
+
+    def test_sorted_by_momentum_score_desc(self):
+        """Industries are sorted by momentum_score descending."""
+        industries = [
+            _make_industry("Low", perf_1w=1, perf_1m=1, perf_3m=1, perf_6m=1),
+            _make_industry("High", perf_1w=20, perf_1m=30, perf_3m=40, perf_6m=50),
+            _make_industry("Mid", perf_1w=5, perf_1m=10, perf_3m=10, perf_6m=10),
+        ]
+        ranked = rank_industries(industries)
+        assert ranked[0]["name"] == "High"
+        assert ranked[-1]["name"] == "Low"
+        # Verify descending order
+        scores = [r["momentum_score"] for r in ranked]
+        assert scores == sorted(scores, reverse=True)
+
+    def test_rank_starts_at_one(self):
+        """Rank should be 1-based."""
+        industries = [
+            _make_industry("A", perf_3m=10),
+            _make_industry("B", perf_3m=20),
+        ]
+        ranked = rank_industries(industries)
+        assert ranked[0]["rank"] == 1
+        assert ranked[1]["rank"] == 2
+
+    def test_bullish_direction_for_positive_return(self):
+        """Positive weighted return -> direction='bullish'."""
+        ranked = rank_industries([_make_industry("Up", perf_3m=15, perf_6m=10)])
+        assert ranked[0]["direction"] == "bullish"
+
+    def test_bearish_direction_for_negative_return(self):
+        """Negative weighted return -> direction='bearish'."""
+        ranked = rank_industries([_make_industry("Down", perf_3m=-15, perf_6m=-10)])
+        assert ranked[0]["direction"] == "bearish"
+
+    def test_zero_return_direction(self):
+        """Zero weighted return -> direction='bearish' (non-positive)."""
+        ranked = rank_industries([_make_industry("Flat")])
+        assert ranked[0]["direction"] == "bearish"
+
+    def test_empty_list_returns_empty(self):
+        """Empty input returns empty list."""
+        assert rank_industries([]) == []
+
+    def test_preserves_original_fields(self):
+        """Original industry dict fields are preserved in output."""
+        ind = _make_industry("Test", perf_1w=5, perf_1m=10, perf_3m=15, perf_6m=20)
+        ind["sector"] = "Technology"  # extra field
+        ranked = rank_industries([ind])
+        assert ranked[0]["name"] == "Test"
+        assert ranked[0]["perf_1w"] == 5
+        assert ranked[0]["sector"] == "Technology"
+
+    def test_mixed_bullish_bearish(self):
+        """Mix of positive and negative returns handled correctly."""
+        industries = [
+            _make_industry("Bull", perf_1w=10, perf_1m=15, perf_3m=20, perf_6m=25),
+            _make_industry("Bear", perf_1w=-10, perf_1m=-15, perf_3m=-20, perf_6m=-25),
+        ]
+        ranked = rank_industries(industries)
+        # Both should have same momentum_score (direction-neutral)
+        assert abs(ranked[0]["momentum_score"] - ranked[1]["momentum_score"]) < 0.01
+        # But different directions
+        directions = {r["name"]: r["direction"] for r in ranked}
+        assert directions["Bull"] == "bullish"
+        assert directions["Bear"] == "bearish"
+
+
+# ---------------------------------------------------------------------------
+# get_top_bottom_industries tests
+# ---------------------------------------------------------------------------
+
+
+class TestGetTopBottomIndustries:
+    """Test top/bottom extraction."""
+
+    def test_top_and_bottom_n(self):
+        """Returns correct top N and bottom N."""
+        industries = [
+            _make_industry(f"Ind{i}", perf_3m=20 - i * 2, perf_6m=15 - i)
+            for i in range(10)
+        ]
+        ranked = rank_industries(industries)
+        result = get_top_bottom_industries(ranked, n=3)
+        assert len(result["top"]) == 3
+        assert len(result["bottom"]) == 3
+        # Top should have rank 1,2,3
+        assert result["top"][0]["rank"] == 1
+        assert result["top"][2]["rank"] == 3
+        # Bottom should have rank 8,9,10
+        assert result["bottom"][0]["rank"] == 8
+        assert result["bottom"][2]["rank"] == 10
+
+    def test_n_greater_than_half(self):
+        """When n > len/2, top and bottom may overlap; should handle gracefully."""
+        industries = [_make_industry(f"I{i}", perf_3m=i) for i in range(4)]
+        ranked = rank_industries(industries)
+        result = get_top_bottom_industries(ranked, n=3)
+        assert len(result["top"]) == 3
+        assert len(result["bottom"]) == 3
+
+    def test_empty_ranked_list(self):
+        """Empty input returns empty top and bottom."""
+        result = get_top_bottom_industries([], n=5)
+        assert result["top"] == []
+        assert result["bottom"] == []
+
+    def test_n_exceeds_list_length(self):
+        """n > len(ranked) returns all available."""
+        industries = [_make_industry(f"I{i}", perf_3m=i * 5) for i in range(3)]
+        ranked = rank_industries(industries)
+        result = get_top_bottom_industries(ranked, n=10)
+        assert len(result["top"]) == 3
+        assert len(result["bottom"]) == 3
+
+    def test_default_n_is_5(self):
+        """Default n should be 5."""
+        industries = [_make_industry(f"I{i}", perf_3m=i * 3) for i in range(20)]
+        ranked = rank_industries(industries)
+        result = get_top_bottom_industries(ranked)
+        assert len(result["top"]) == 5
+        assert len(result["bottom"]) == 5