Buckets:
AnonymousSpottedToad/human_verified_bucket / codebase /python /luxman89_TradeArena /tests /test_analytics.py
| """Tests for per-creator performance analytics computation.""" | |
| from __future__ import annotations | |
| from datetime import UTC, datetime, timedelta | |
| from types import SimpleNamespace | |
| from tradearena.core.analytics import ( | |
| compute_action_distribution, | |
| compute_analytics, | |
| compute_asset_performance, | |
| compute_confidence_calibration_curve, | |
| compute_drawdown_series, | |
| compute_equity_curve, | |
| compute_outcome_distribution, | |
| compute_signal_frequency, | |
| compute_streaks, | |
| compute_timeframe_performance, | |
| ) | |
| def _sig( | |
| outcome=None, | |
| confidence=0.5, | |
| action="buy", | |
| committed_at=None, | |
| asset="BTCUSDT", | |
| timeframe="1d", | |
| **kwargs, | |
| ): | |
| """Create a lightweight signal-like object for analytics tests.""" | |
| if committed_at is None: | |
| committed_at = datetime.now(UTC) | |
| return SimpleNamespace( | |
| outcome=outcome, | |
| confidence=confidence, | |
| action=action, | |
| committed_at=committed_at, | |
| asset=asset, | |
| timeframe=timeframe, | |
| **kwargs, | |
| ) | |
| # ── Equity curve ────────────────────────────────────────────────────────── | |
| class TestEquityCurve: | |
| def test_empty_signals(self): | |
| assert compute_equity_curve([]) == [] | |
| def test_only_pending(self): | |
| sigs = [_sig(outcome=None), _sig(outcome=None)] | |
| assert compute_equity_curve(sigs) == [] | |
| def test_cumulative_wins(self): | |
| t1 = datetime(2025, 1, 1, tzinfo=UTC) | |
| t2 = datetime(2025, 1, 2, tzinfo=UTC) | |
| sigs = [_sig(outcome="WIN", committed_at=t1), _sig(outcome="WIN", committed_at=t2)] | |
| curve = compute_equity_curve(sigs) | |
| assert len(curve) == 2 | |
| assert curve[0]["value"] == 1.0 | |
| assert curve[1]["value"] == 2.0 | |
| def test_win_then_loss(self): | |
| t1 = datetime(2025, 1, 1, tzinfo=UTC) | |
| t2 = datetime(2025, 1, 2, tzinfo=UTC) | |
| sigs = [_sig(outcome="WIN", committed_at=t1), _sig(outcome="LOSS", committed_at=t2)] | |
| curve = compute_equity_curve(sigs) | |
| assert curve[-1]["value"] == 0.0 | |
| def test_neutral_no_change(self): | |
| t1 = datetime(2025, 1, 1, tzinfo=UTC) | |
| t2 = datetime(2025, 1, 2, tzinfo=UTC) | |
| sigs = [ | |
| _sig(outcome="WIN", committed_at=t1), | |
| _sig(outcome="NEUTRAL", committed_at=t2), | |
| ] | |
| curve = compute_equity_curve(sigs) | |
| assert curve[0]["value"] == 1.0 | |
| assert curve[1]["value"] == 1.0 | |
| def test_sorted_by_time(self): | |
| t1 = datetime(2025, 1, 2, tzinfo=UTC) | |
| t2 = datetime(2025, 1, 1, tzinfo=UTC) | |
| sigs = [_sig(outcome="WIN", committed_at=t1), _sig(outcome="LOSS", committed_at=t2)] | |
| curve = compute_equity_curve(sigs) | |
| # t2 (loss) comes first chronologically | |
| assert curve[0]["value"] == -1.0 | |
| assert curve[1]["value"] == 0.0 | |
| # ── Drawdown ────────────────────────────────────────────────────────────── | |
| class TestDrawdownSeries: | |
| def test_empty(self): | |
| assert compute_drawdown_series([]) == [] | |
| def test_monotone_up(self): | |
| equity = [ | |
| {"timestamp": "2025-01-01", "value": 1.0}, | |
| {"timestamp": "2025-01-02", "value": 2.0}, | |
| ] | |
| dd = compute_drawdown_series(equity) | |
| assert all(p["value"] == 0.0 for p in dd) | |
| def test_drawdown_after_peak(self): | |
| equity = [ | |
| {"timestamp": "2025-01-01", "value": 3.0}, | |
| {"timestamp": "2025-01-02", "value": 1.0}, | |
| ] | |
| dd = compute_drawdown_series(equity) | |
| assert dd[0]["value"] == 0.0 | |
| assert dd[1]["value"] == -2.0 | |
| # ── Streaks ─────────────────────────────────────────────────────────────── | |
| class TestStreaks: | |
| def test_empty(self): | |
| result = compute_streaks([]) | |
| assert result["max_win_streak"] == 0 | |
| assert result["max_loss_streak"] == 0 | |
| def test_all_wins(self): | |
| t = datetime(2025, 1, 1, tzinfo=UTC) | |
| sigs = [_sig(outcome="WIN", committed_at=t + timedelta(days=i)) for i in range(5)] | |
| result = compute_streaks(sigs) | |
| assert result["max_win_streak"] == 5 | |
| assert result["current_win_streak"] == 5 | |
| assert result["current_loss_streak"] == 0 | |
| def test_all_losses(self): | |
| t = datetime(2025, 1, 1, tzinfo=UTC) | |
| sigs = [_sig(outcome="LOSS", committed_at=t + timedelta(days=i)) for i in range(3)] | |
| result = compute_streaks(sigs) | |
| assert result["max_loss_streak"] == 3 | |
| assert result["current_loss_streak"] == 3 | |
| assert result["current_win_streak"] == 0 | |
| def test_mixed(self): | |
| t = datetime(2025, 1, 1, tzinfo=UTC) | |
| outcomes = ["WIN", "WIN", "WIN", "LOSS", "LOSS", "WIN"] | |
| sigs = [_sig(outcome=o, committed_at=t + timedelta(days=i)) for i, o in enumerate(outcomes)] | |
| result = compute_streaks(sigs) | |
| assert result["max_win_streak"] == 3 | |
| assert result["max_loss_streak"] == 2 | |
| assert result["current_win_streak"] == 1 | |
| def test_pending_and_neutral_ignored(self): | |
| t = datetime(2025, 1, 1, tzinfo=UTC) | |
| sigs = [ | |
| _sig(outcome="WIN", committed_at=t), | |
| _sig(outcome=None, committed_at=t + timedelta(days=1)), | |
| _sig(outcome="NEUTRAL", committed_at=t + timedelta(days=2)), | |
| ] | |
| result = compute_streaks(sigs) | |
| assert result["max_win_streak"] == 1 | |
| # ── Action distribution ────────────────────────────────────────────────── | |
| class TestActionDistribution: | |
| def test_empty(self): | |
| assert compute_action_distribution([]) == {} | |
| def test_counts(self): | |
| sigs = [_sig(action="buy"), _sig(action="buy"), _sig(action="sell")] | |
| dist = compute_action_distribution(sigs) | |
| assert dist == {"buy": 2, "sell": 1} | |
| # ── Confidence calibration ─────────────────────────────────────────────── | |
| class TestConfidenceCalibrationCurve: | |
| def test_empty(self): | |
| assert compute_confidence_calibration_curve([]) == [] | |
| def test_only_pending(self): | |
| sigs = [_sig(outcome=None, confidence=0.8)] | |
| assert compute_confidence_calibration_curve(sigs) == [] | |
| def test_single_bucket(self): | |
| sigs = [ | |
| _sig(outcome="WIN", confidence=0.85), | |
| _sig(outcome="LOSS", confidence=0.82), | |
| ] | |
| curve = compute_confidence_calibration_curve(sigs) | |
| assert len(curve) == 1 | |
| assert curve[0]["predicted_confidence"] == 0.85 # bucket 8 midpoint | |
| assert curve[0]["actual_win_rate"] == 0.5 | |
| assert curve[0]["sample_count"] == 2 | |
| def test_multiple_buckets(self): | |
| sigs = [ | |
| _sig(outcome="WIN", confidence=0.15), | |
| _sig(outcome="WIN", confidence=0.75), | |
| _sig(outcome="WIN", confidence=0.76), | |
| ] | |
| curve = compute_confidence_calibration_curve(sigs) | |
| assert len(curve) == 2 # bucket 1 and bucket 7 | |
| # ── Full analytics pipeline ────────────────────────────────────────────── | |
| class TestComputeAnalytics: | |
| def test_all_range(self): | |
| t = datetime(2025, 1, 1, tzinfo=UTC) | |
| sigs = [ | |
| _sig(outcome="WIN", confidence=0.7, action="buy", committed_at=t), | |
| _sig(outcome="LOSS", confidence=0.3, action="sell", committed_at=t + timedelta(days=1)), | |
| ] | |
| result = compute_analytics(sigs, "all") | |
| assert result["range"] == "all" | |
| assert result["total_signals"] == 2 | |
| assert result["resolved_signals"] == 2 | |
| assert len(result["equity_curve"]) == 2 | |
| assert len(result["drawdown_series"]) == 2 | |
| assert result["streaks"]["max_win_streak"] == 1 | |
| assert result["action_distribution"] == {"buy": 1, "sell": 1} | |
| assert len(result["confidence_calibration_curve"]) >= 1 | |
| def test_time_range_filter(self): | |
| old = datetime.now(UTC) - timedelta(days=60) | |
| recent = datetime.now(UTC) - timedelta(days=1) | |
| sigs = [ | |
| _sig(outcome="WIN", committed_at=old), | |
| _sig(outcome="LOSS", committed_at=recent), | |
| ] | |
| result_30d = compute_analytics(sigs, "30d") | |
| assert result_30d["total_signals"] == 1 # only recent | |
| result_all = compute_analytics(sigs, "all") | |
| assert result_all["total_signals"] == 2 | |
| def test_empty_signals(self): | |
| result = compute_analytics([], "all") | |
| assert result["total_signals"] == 0 | |
| assert result["equity_curve"] == [] | |
| assert result["streaks"]["max_win_streak"] == 0 | |
| assert result["signal_frequency"] == [] | |
| assert result["outcome_distribution"]["counts"]["WIN"] == 0 | |
| assert result["asset_performance"] == [] | |
| assert result["timeframe_performance"] == [] | |
| def test_includes_new_fields(self): | |
| t = datetime(2025, 1, 1, tzinfo=UTC) | |
| sigs = [ | |
| _sig(outcome="WIN", asset="BTCUSDT", timeframe="1d", committed_at=t), | |
| _sig( | |
| outcome="LOSS", | |
| asset="ETHUSDT", | |
| timeframe="4h", | |
| committed_at=t + timedelta(days=1), | |
| ), | |
| ] | |
| result = compute_analytics(sigs, "all") | |
| assert len(result["signal_frequency"]) == 2 | |
| assert result["outcome_distribution"]["counts"]["WIN"] == 1 | |
| assert len(result["asset_performance"]) == 2 | |
| assert len(result["timeframe_performance"]) == 2 | |
| # ── Signal frequency ──────────────────────────────────────────────────── | |
| class TestSignalFrequency: | |
| def test_empty(self): | |
| assert compute_signal_frequency([]) == [] | |
| def test_single_day(self): | |
| t = datetime(2025, 1, 5, 10, 0, tzinfo=UTC) | |
| sigs = [_sig(committed_at=t), _sig(committed_at=t + timedelta(hours=2))] | |
| result = compute_signal_frequency(sigs) | |
| assert len(result) == 1 | |
| assert result[0]["date"] == "2025-01-05" | |
| assert result[0]["count"] == 2 | |
| def test_multiple_days_sorted(self): | |
| t1 = datetime(2025, 1, 3, tzinfo=UTC) | |
| t2 = datetime(2025, 1, 1, tzinfo=UTC) | |
| t3 = datetime(2025, 1, 3, 12, 0, tzinfo=UTC) | |
| sigs = [_sig(committed_at=t1), _sig(committed_at=t2), _sig(committed_at=t3)] | |
| result = compute_signal_frequency(sigs) | |
| assert len(result) == 2 | |
| assert result[0]["date"] == "2025-01-01" | |
| assert result[0]["count"] == 1 | |
| assert result[1]["date"] == "2025-01-03" | |
| assert result[1]["count"] == 2 | |
| # ── Outcome distribution ──────────────────────────────────────────────── | |
| class TestOutcomeDistribution: | |
| def test_empty(self): | |
| result = compute_outcome_distribution([]) | |
| assert result["counts"] == {"WIN": 0, "LOSS": 0, "NEUTRAL": 0, "pending": 0} | |
| def test_mixed_outcomes(self): | |
| sigs = [ | |
| _sig(outcome="WIN"), | |
| _sig(outcome="WIN"), | |
| _sig(outcome="LOSS"), | |
| _sig(outcome="NEUTRAL"), | |
| _sig(outcome=None), | |
| ] | |
| result = compute_outcome_distribution(sigs) | |
| assert result["counts"]["WIN"] == 2 | |
| assert result["counts"]["LOSS"] == 1 | |
| assert result["counts"]["NEUTRAL"] == 1 | |
| assert result["counts"]["pending"] == 1 | |
| assert result["percentages"]["WIN"] == 0.4 | |
| def test_all_pending(self): | |
| sigs = [_sig(outcome=None), _sig(outcome=None)] | |
| result = compute_outcome_distribution(sigs) | |
| assert result["counts"]["pending"] == 2 | |
| assert result["percentages"]["pending"] == 1.0 | |
| # ── Asset performance ─────────────────────────────────────────────────── | |
| class TestAssetPerformance: | |
| def test_empty(self): | |
| assert compute_asset_performance([]) == [] | |
| def test_single_asset(self): | |
| sigs = [ | |
| _sig(outcome="WIN", asset="BTCUSDT"), | |
| _sig(outcome="LOSS", asset="BTCUSDT"), | |
| _sig(outcome="WIN", asset="BTCUSDT"), | |
| ] | |
| result = compute_asset_performance(sigs) | |
| assert len(result) == 1 | |
| assert result[0]["asset"] == "BTCUSDT" | |
| assert result[0]["total"] == 3 | |
| assert result[0]["wins"] == 2 | |
| assert result[0]["losses"] == 1 | |
| assert result[0]["win_rate"] == round(2 / 3, 4) | |
| def test_multiple_assets_sorted(self): | |
| sigs = [ | |
| _sig(outcome="WIN", asset="ETHUSDT"), | |
| _sig(outcome="LOSS", asset="BTCUSDT"), | |
| ] | |
| result = compute_asset_performance(sigs) | |
| assert result[0]["asset"] == "BTCUSDT" | |
| assert result[1]["asset"] == "ETHUSDT" | |
| def test_no_resolved_win_rate_none(self): | |
| sigs = [_sig(outcome=None, asset="BTCUSDT")] | |
| result = compute_asset_performance(sigs) | |
| assert result[0]["win_rate"] is None | |
| assert result[0]["total"] == 1 | |
| # ── Timeframe performance ─────────────────────────────────────────────── | |
| class TestTimeframePerformance: | |
| def test_empty(self): | |
| assert compute_timeframe_performance([]) == [] | |
| def test_single_timeframe(self): | |
| sigs = [ | |
| _sig(outcome="WIN", timeframe="4h"), | |
| _sig(outcome="WIN", timeframe="4h"), | |
| _sig(outcome="LOSS", timeframe="4h"), | |
| ] | |
| result = compute_timeframe_performance(sigs) | |
| assert len(result) == 1 | |
| assert result[0]["timeframe"] == "4h" | |
| assert result[0]["win_rate"] == round(2 / 3, 4) | |
| def test_unspecified_timeframe(self): | |
| sigs = [_sig(outcome="WIN", timeframe=None)] | |
| result = compute_timeframe_performance(sigs) | |
| assert result[0]["timeframe"] == "unspecified" | |
| def test_multiple_timeframes(self): | |
| sigs = [ | |
| _sig(outcome="WIN", timeframe="1h"), | |
| _sig(outcome="LOSS", timeframe="1d"), | |
| ] | |
| result = compute_timeframe_performance(sigs) | |
| assert len(result) == 2 | |
| assert result[0]["timeframe"] == "1d" | |
| assert result[1]["timeframe"] == "1h" | |
Xet Storage Details
- Size:
- 14.8 kB
- Xet hash:
- d4ea8a1abffe9be400f06d5aa6dae30dd33d202c365ca381d5b1ab1ccab8810d
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.