traderbot 0.14.72__py3-none-any.whl

traderbot/__init__.py

@@ -0,0 +1,13 @@
+"""TraderBot — Autonomous prediction market investment toolkit for Kalshi."""
+
+import importlib.metadata
+from pathlib import Path
+
+_ver_file = Path(__file__).resolve().parent.parent.parent / "VERSION"
+if _ver_file.exists():
+    __version__ = _ver_file.read_text().strip().lstrip("v")
+else:
+    try:
+        __version__ = importlib.metadata.version("traderbot")
+    except importlib.metadata.PackageNotFoundError:
+        __version__ = "0.0.0"

traderbot/analysis/__init__.py

@@ -0,0 +1,81 @@
+"""Statistical computation and signal generation for binary prediction markets."""
+
+from __future__ import annotations
+
+from traderbot.analysis.indicators import (
+    BollingerBands,
+    IndicatorResult,
+    MovingAverageResult,
+    bollinger_bands,
+    ema,
+    rsi,
+    sma,
+    volume_weighted_price,
+)
+from traderbot.analysis.odds import (
+    EdgeEstimate,
+    ImpliedProb,
+    KellyInputs,
+    compute_kelly_inputs,
+    detect_edge,
+    expected_value,
+    implied_probability,
+)
+from traderbot.analysis.portfolio import (
+    PortfolioMetrics,
+    brier_score,
+    calibration_curve,
+    calmar_ratio,
+    edge_realization,
+    max_drawdown,
+    sharpe_ratio,
+    win_rate,
+)
+from traderbot.analysis.registry import (
+    AnalysisRegistry,
+    CategoryAnalyzer,
+    CategorySignals,
+    GenericAnalyzer,
+)
+from traderbot.analysis.signals import (
+    CombinedSignal,
+    SignalSource,
+    combine_signals,
+    default_weights,
+    generate_signal,
+)
+
+__all__ = [
+    "AnalysisRegistry",
+    "BollingerBands",
+    "CategoryAnalyzer",
+    "CategorySignals",
+    "CombinedSignal",
+    "EdgeEstimate",
+    "GenericAnalyzer",
+    "ImpliedProb",
+    "IndicatorResult",
+    "KellyInputs",
+    "MovingAverageResult",
+    "PortfolioMetrics",
+    "SignalSource",
+    "bollinger_bands",
+    "brier_score",
+    "calibration_curve",
+    "calmar_ratio",
+    "combine_signals",
+    "compute_kelly_inputs",
+    "default_weights",
+    "detect_edge",
+    "edge_realization",
+    "ema",
+    "expected_value",
+    "generate_signal",
+    "implied_probability",
+    "max_drawdown",
+    "rsi",
+    "sharpe_ratio",
+    "sma",
+    "volume_weighted_price",
+    "win_rate",
+]

traderbot/analysis/indicators.py

@@ -0,0 +1,120 @@
+"""Technical indicators adapted for binary prediction markets."""
+
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+import math
+from datetime import datetime  # noqa: TC003
+
+from pydantic import BaseModel, ConfigDict
+
+from traderbot.kalshi.models import Trade  # noqa: TC001
+
+
+class IndicatorResult(BaseModel):
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    name: str
+    value: float
+    timestamp: datetime
+
+
+class MovingAverageResult(BaseModel):
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    sma: float
+    ema: float
+    period: int
+
+
+class BollingerBands(BaseModel):
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    lower: int
+    middle: int
+    upper: int
+
+
+def sma(prices: list[int], period: int) -> float:
+    """Simple moving average of the last *period* prices (or all if fewer)."""
+    if not prices:
+        raise ValueError("prices must not be empty")
+    n = min(period, len(prices))
+    return sum(prices[-n:]) / n
+
+
+def ema(prices: list[int], period: int) -> float:
+    """Exponential moving average with multiplier 2/(period+1)."""
+    if not prices:
+        raise ValueError("prices must not be empty")
+    mult = 2 / (period + 1)
+    if len(prices) == 1:
+        return float(prices[0])
+    n = min(period, len(prices))
+    result = sum(prices[:n]) / n
+    for price in prices[n:]:
+        result = price * mult + result * (1 - mult)
+    return result
+
+
+def rsi(prices: list[int], period: int = 14) -> float:
+    """Wilder's RSI using exponential smoothing on price deltas."""
+    if not prices:
+        raise ValueError("prices must not be empty")
+    if len(prices) < 2:
+        return 50.0
+
+    deltas = [prices[i + 1] - prices[i] for i in range(len(prices) - 1)]
+
+    gains: list[float] = []
+    losses: list[float] = []
+    for d in deltas:
+        gains.append(float(d) if d > 0 else 0.0)
+        losses.append(float(-d) if d < 0 else 0.0)
+
+    n = min(period, len(deltas))
+    avg_gain = sum(gains[:n]) / n
+    avg_loss = sum(losses[:n]) / n
+
+    for i in range(n, len(deltas)):
+        avg_gain = (avg_gain * (period - 1) + gains[i]) / period
+        avg_loss = (avg_loss * (period - 1) + losses[i]) / period
+
+    if avg_gain == 0 and avg_loss == 0:
+        return 50.0
+    if avg_loss == 0:
+        return 100.0
+    if avg_gain == 0:
+        return 0.0
+
+    rs = avg_gain / avg_loss
+    return 100.0 - (100.0 / (1.0 + rs))
+
+
+def bollinger_bands(prices: list[int], period: int = 20, k: float = 2.0) -> BollingerBands:
+    """Bollinger Bands with population standard deviation, returned as int cents."""
+    if not prices:
+        raise ValueError("prices must not be empty")
+    n = min(period, len(prices))
+    window = prices[-n:]
+    middle = sum(window) / n
+    variance = sum((p - middle) ** 2 for p in window) / n
+    std = math.sqrt(variance)
+    return BollingerBands(
+        lower=round(middle - k * std),
+        middle=round(middle),
+        upper=round(middle + k * std),
+    )
+
+
+def volume_weighted_price(trades: list[Trade]) -> int:
+    """Volume-weighted average price, returned as int cents."""
+    # TODO: Wire into generate_signal()
+    if not trades:
+        raise ValueError("trades must not be empty")
+    total_value = sum(t.price * t.quantity for t in trades)
+    total_qty = sum(t.quantity for t in trades)
+    return round(total_value / total_qty)

traderbot/analysis/odds.py

@@ -0,0 +1,110 @@
+"""Implied probability, edge detection, and Kelly criterion for binary markets."""
+
+from __future__ import annotations
+
+import logging
+
+from typing import TYPE_CHECKING, Literal
+
+logger = logging.getLogger(__name__)
+
+logger = logging.getLogger(__name__)
+
+from pydantic import BaseModel, ConfigDict
+
+if TYPE_CHECKING:
+    from traderbot.kalshi.models import OrderBook
+
+
+class ImpliedProb(BaseModel):
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    yes_prob: float
+    no_prob: float
+    spread_cents: int
+    mid_price_cents: int
+
+
+class EdgeEstimate(BaseModel):
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    estimated_prob: float
+    market_prob: float
+    edge: float
+    direction: Literal["yes", "no", "neutral"]
+
+
+class KellyInputs(BaseModel):
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    prob: float
+    odds: float
+    edge: float
+    kelly_fraction: float
+
+
+def implied_probability(orderbook: OrderBook) -> ImpliedProb:
+    """Extract implied probabilities from bid data in a binary order book."""
+    best_yes_bid = max((lvl.price for lvl in orderbook.yes_bids), default=0)
+    best_no_bid = max((lvl.price for lvl in orderbook.no_bids), default=0)
+
+    if best_yes_bid == 0 and best_no_bid == 0:
+        raise ValueError("Order book has no bids on either side")
+
+    yes_prob = best_yes_bid / 100.0
+    no_prob = best_no_bid / 100.0
+    best_yes_ask = 100 - best_no_bid
+    spread_cents = best_yes_ask - best_yes_bid
+    mid_price_cents = max(1, round((best_yes_bid + best_yes_ask) / 2))
+
+    return ImpliedProb(
+        yes_prob=yes_prob,
+        no_prob=no_prob,
+        spread_cents=spread_cents,
+        mid_price_cents=mid_price_cents,
+    )
+
+
+def detect_edge(estimated_prob: float, orderbook: OrderBook) -> EdgeEstimate:
+    """Compare estimated probability against market-implied probability."""
+    market_prob = implied_probability(orderbook).yes_prob
+    edge = estimated_prob - market_prob
+
+    if abs(edge) < 0.01:
+        direction: Literal["yes", "no", "neutral"] = "neutral"
+    elif edge > 0:
+        direction = "yes"
+    else:
+        direction = "no"
+
+    return EdgeEstimate(
+        estimated_prob=estimated_prob,
+        market_prob=market_prob,
+        edge=edge,
+        direction=direction,
+    )
+
+
+def compute_kelly_inputs(estimated_prob: float, market_price_cents: int) -> KellyInputs:
+    """Compute Kelly criterion fraction for a binary market position."""
+    profit = 100 - market_price_cents
+    loss = market_price_cents
+    odds = profit / loss
+    edge = estimated_prob - (market_price_cents / 100.0)
+    kelly = (estimated_prob * odds - (1 - estimated_prob)) / odds
+    kelly_fraction = max(0.0, min(1.0, kelly))
+
+    return KellyInputs(
+        prob=estimated_prob,
+        odds=odds,
+        edge=edge,
+        kelly_fraction=kelly_fraction,
+    )
+
+
+def expected_value(prob: float, market_price_cents: int, quantity: int = 1) -> int:
+    """Compute expected value in cents for a yes-position in a binary market."""
+    profit_per = 100 - market_price_cents
+    loss_per = market_price_cents
+    ev = prob * profit_per * quantity - (1 - prob) * loss_per * quantity
+    return round(ev)

traderbot/analysis/portfolio.py

@@ -0,0 +1,138 @@
+"""Portfolio analytics: calibration, risk metrics, and edge realization."""
+
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+import math
+
+logger = logging.getLogger(__name__)
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict
+
+if TYPE_CHECKING:
+    from traderbot.kalshi.models import Decision
+
+
+class PortfolioMetrics(BaseModel):
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    total_trades: int
+    win_rate: float
+    brier_score: float
+    sharpe_ratio: float | None
+    max_drawdown_pct: float
+    calmar_ratio: float | None
+    total_pnl_cents: int
+    avg_edge_realization: float
+
+
+def win_rate(decisions: list[Decision]) -> float:
+    """Fraction of executed decisions that predicted correctly."""
+    qualifying = [d for d in decisions if d.outcome == "executed" and d.actual_result is not None]
+    if not qualifying:
+        return 0.0
+    wins = sum(
+        1
+        for d in qualifying
+        if (d.direction == "yes" and d.actual_result is True)
+        or (d.direction == "no" and d.actual_result is False)
+    )
+    return wins / len(qualifying)
+
+
+def brier_score(predictions: list[tuple[float, bool]]) -> float:
+    """Mean squared error of probabilistic predictions."""
+    if not predictions:
+        return 0.0
+    total = sum((prob - float(actual)) ** 2 for prob, actual in predictions)
+    return total / len(predictions)
+
+
+def calibration_curve(
+    predictions: list[tuple[float, bool]], buckets: int = 10
+) -> list[tuple[float, float]]:
+    """Observed frequency per predicted-probability bucket."""
+    bin_sums: dict[int, list[tuple[float, bool]]] = {}
+    for prob, actual in predictions:
+        idx = min(int(prob * buckets), buckets - 1)
+        bin_sums.setdefault(idx, []).append((prob, actual))
+
+    result: list[tuple[float, float]] = []
+    for i in range(buckets):
+        if i not in bin_sums:
+            continue
+        items = bin_sums[i]
+        mean_pred = sum(p for p, _ in items) / len(items)
+        obs_freq = sum(1 for _, a in items if a) / len(items)
+        result.append((mean_pred, obs_freq))
+    return result
+
+
+def sharpe_ratio(returns: list[float], risk_free: float = 0.0) -> float | None:
+    """Annualized Sharpe ratio from periodic returns."""
+    if len(returns) < 2:
+        return None
+    excess = [r - risk_free for r in returns]
+    mean_excess = sum(excess) / len(excess)
+    variance = sum((e - mean_excess) ** 2 for e in excess) / (len(excess) - 1)
+    if variance < 1e-15:
+        return None
+    return mean_excess / math.sqrt(variance) * math.sqrt(252)
+
+
+def max_drawdown(values: list[int]) -> float:
+    """Maximum fractional drawdown from running peak."""
+    if not values:
+        return 0.0
+    peak = 0
+    max_dd = 0.0
+    for val in values:
+        if val > peak:
+            peak = val
+        if peak > 0:
+            dd = (peak - val) / peak
+            if dd > max_dd:
+                max_dd = dd
+    return max_dd
+
+
+def calmar_ratio(annualized_return: float, max_dd: float) -> float | None:
+    """Annualized return divided by maximum drawdown."""
+    if max_dd == 0.0:
+        return None
+    return annualized_return / max_dd
+
+
+def edge_realization(decisions: list[Decision]) -> float:
+    """Average ratio of actual-vs-expected PnL per executed decision."""
+    qualifying: list[tuple[int, int]] = []
+    for d in decisions:
+        if d.outcome != "executed" or d.actual_result is None:
+            continue
+        # actual PnL in cents
+        if d.direction == "yes":
+            if d.actual_result is True:
+                actual_pnl = (100 - d.price) * d.quantity
+            else:
+                actual_pnl = -d.price * d.quantity
+        elif d.direction == "no":
+            if d.actual_result is False:
+                actual_pnl = (100 - d.price) * d.quantity
+            else:
+                actual_pnl = -d.price * d.quantity
+        else:
+            continue
+
+        expected_pnl = abs(d.edge_estimate) * d.quantity * d.price
+        if expected_pnl == 0:
+            continue
+        qualifying.append((actual_pnl, expected_pnl))
+
+    if not qualifying:
+        return 0.0
+    realization_sum = sum((actual - expected) / abs(expected) for actual, expected in qualifying)
+    return realization_sum / len(qualifying)

traderbot/analysis/registry.py

@@ -0,0 +1,102 @@
+"""Category-based analysis registry with protocol-based analyzer dispatch."""
+
+from __future__ import annotations
+
+import logging
+
+from typing import Annotated, Protocol, runtime_checkable
+
+logger = logging.getLogger(__name__)
+
+logger = logging.getLogger(__name__)
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from traderbot.analysis.indicators import bollinger_bands, ema, rsi
+from traderbot.analysis.odds import detect_edge
+from traderbot.analysis.signals import generate_signal
+from traderbot.kalshi.models import MarketCategory  # noqa: TC001
+
+
+class CategorySignals(BaseModel):
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    category: MarketCategory
+    signals: list[str]
+    confidence: Annotated[float, Field(ge=0, le=1)]
+    data_sources: list[str]
+
+
+@runtime_checkable
+class CategoryAnalyzer(Protocol):
+    def analyze(self, market_data: dict, category: MarketCategory) -> CategorySignals: ...
+
+
+class AnalysisRegistry:
+    def __init__(self) -> None:
+        self._analyzers: dict[MarketCategory, CategoryAnalyzer] = {}
+
+    def register(self, category: MarketCategory, analyzer: CategoryAnalyzer) -> None:
+        self._analyzers[category] = analyzer
+
+    def get(self, category: MarketCategory) -> CategoryAnalyzer:
+        if category in self._analyzers:
+            return self._analyzers[category]
+        return self._default
+
+    def analyze(self, market_data: dict, category: MarketCategory) -> CategorySignals:
+        analyzer = self.get(category)
+        return analyzer.analyze(market_data, category)
+
+    @property
+    def _default(self) -> CategoryAnalyzer:
+        return GenericAnalyzer()
+
+
+class GenericAnalyzer:
+    """Wraps the existing indicator/odds/signal pipeline as the default analyzer."""
+
+    def analyze(self, market_data: dict, category: MarketCategory) -> CategorySignals:
+        prices: list[int] = market_data.get("prices", [])
+        trades = market_data.get("trades", [])
+        orderbook = market_data.get("orderbook")
+        estimated_prob: float = market_data.get("estimated_prob", 0.5)
+        ticker: str = market_data.get("ticker", "UNKNOWN")
+
+        signals: list[str] = []
+        data_sources: list[str] = []
+        confidence = 0.0
+
+        if len(prices) >= 2:
+            rsi_val = rsi(prices, period=14)
+            signals.append(f"RSI={rsi_val:.1f}")
+            data_sources.append("rsi")
+
+            bb = bollinger_bands(prices, period=20, k=2.0)
+            signals.append(f"BB=[{bb.lower},{bb.middle},{bb.upper}]")
+            data_sources.append("bollinger")
+
+            short = ema(prices, 5)
+            long = ema(prices, 20)
+            signals.append(f"EMA5={short:.1f},EMA20={long:.1f}")
+            data_sources.append("ema")
+
+        if orderbook is not None:
+            edge = detect_edge(estimated_prob, orderbook)
+            signals.append(f"edge={edge.edge:.3f},dir={edge.direction}")
+            data_sources.append("odds")
+
+        if prices and trades and orderbook is not None:
+            combined = generate_signal(ticker, prices, orderbook, estimated_prob)
+            confidence = combined.confidence
+            signals.append(f"combined={combined.direction},conf={combined.confidence:.2f}")
+            data_sources.append("signals")
+        else:
+            confidence = 0.3
+
+        return CategorySignals(
+            category=category,
+            signals=signals,
+            confidence=confidence,
+            data_sources=data_sources,
+        )