alloc-context 0.1.0__py3-none-any.whl

alloccontext/config.py

@@ -0,0 +1,415 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+import yaml
+
+from alloccontext.rollup.cluster_config import RollupConfig, load_rollup_config
+
+
+@dataclass(frozen=True)
+class PathsConfig:
+    db: Path
+
+
+@dataclass(frozen=True)
+class PortfolioConfig:
+    target_allocations: dict[str, float]
+    rebalance_band: float
+    max_cash_risk_off: float
+    notes: str
+
+
+@dataclass(frozen=True)
+class HorizonConfig:
+    """Quarterly scope for stored history (default 90 days)."""
+
+    days: int
+
+
+_KALSHI_ALLOWED_HOSTS = frozenset(
+    {
+        "api.elections.kalshi.com",
+        "trading-api.kalshi.com",
+    }
+)
+
+
+def _validate_kalshi_base_url(url: str) -> str:
+    normalized = url.strip().rstrip("/")
+    parsed = urlparse(normalized)
+    if parsed.scheme != "https":
+        raise ValueError(f"kalshi.base_url must use https, got {parsed.scheme!r}")
+    host = (parsed.hostname or "").lower()
+    if host not in _KALSHI_ALLOWED_HOSTS:
+        allowed = ", ".join(sorted(_KALSHI_ALLOWED_HOSTS))
+        raise ValueError(f"kalshi.base_url host {host!r} not allowed ({allowed})")
+    return normalized
+
+
+DEFAULT_OPTIONAL_INGEST_SOURCES = frozenset(
+    {
+        "fred",
+        "finnhub",
+        "fmp",
+        "coingecko",
+        "coinmarketcap",
+        "sosovalue",
+    }
+)
+
+
+@dataclass(frozen=True)
+class IngestConfig:
+    interval_minutes: int
+    sources: dict[str, bool]
+    optional_sources: frozenset[str]
+
+
+@dataclass(frozen=True)
+class KrakenConfig:
+    ohlc_interval_minutes: int
+    pairs: list[str]
+    retry_backoff_seconds: float
+    max_retries: int
+
+
+@dataclass(frozen=True)
+class SpotExchangeConfig:
+    enabled: bool
+    ohlc_interval_minutes: int
+    pairs: list[str]
+    retry_backoff_seconds: float
+    max_retries: int
+
+
+@dataclass(frozen=True)
+class ExchangesConfig:
+    primary: str
+    kraken: SpotExchangeConfig
+    coinbase: SpotExchangeConfig
+
+    def primary_spot(self) -> SpotExchangeConfig:
+        if self.primary == "kraken":
+            return self.kraken
+        if self.primary == "coinbase":
+            return self.coinbase
+        raise ValueError(f"unsupported primary exchange: {self.primary}")
+
+
+@dataclass(frozen=True)
+class KalshiSeriesConfig:
+    asset: str
+    series: str
+    cf_index: str
+
+
+@dataclass(frozen=True)
+class KalshiConfig:
+    use_api: bool
+    base_url: str
+    timeout_seconds: float
+    cf_history_max_age_minutes: int
+    series: list[KalshiSeriesConfig]
+    fallback_tactical_snapshot: Path | None
+    fallback_state: Path | None
+    fallback_daily_archive: Path | None
+
+
+@dataclass(frozen=True)
+class MacroConfig:
+    static_calendar: Path
+    countries: list[str]
+    min_impact: str
+    fetch_past_days: int
+    fetch_future_days: int
+    finnhub_enabled: bool
+    fmp_enabled: bool
+    timeout_seconds: float
+
+
+@dataclass(frozen=True)
+class EtfConfig:
+    assets: list[str]
+    sosovalue_enabled: bool
+    fallback_snapshot: Path | None
+    timeout_seconds: float
+
+
+@dataclass(frozen=True)
+class CoingeckoConfig:
+    coin_ids: list[str]
+    use_demo_key: bool
+    timeout_seconds: float
+
+
+@dataclass(frozen=True)
+class FredSeriesSpec:
+    id: str
+    label: str
+    category: str
+
+
+@dataclass(frozen=True)
+class FredConfig:
+    series: list[FredSeriesSpec]
+    lookback_days: int
+    timeout_seconds: float
+
+
+@dataclass(frozen=True)
+class CoinmarketcapConfig:
+    symbols: list[str]
+    timeout_seconds: float
+
+
+@dataclass(frozen=True)
+class AppConfig:
+    paths: PathsConfig
+    horizon: HorizonConfig
+    portfolio: PortfolioConfig
+    ingest: IngestConfig
+    kraken: KrakenConfig
+    exchanges: ExchangesConfig
+    kalshi: KalshiConfig
+    rollup: RollupConfig
+    macro: MacroConfig
+    etf: EtfConfig
+    coingecko: CoingeckoConfig
+    coinmarketcap: CoinmarketcapConfig
+    fred: FredConfig
+
+
+def _path(value: str | None, fallback: str) -> Path:
+    return Path(value or fallback)
+
+
+def _optional_ingest_sources(raw: Any) -> frozenset[str]:
+    if raw is None:
+        return DEFAULT_OPTIONAL_INGEST_SOURCES
+    if not isinstance(raw, (list, tuple)):
+        return DEFAULT_OPTIONAL_INGEST_SOURCES
+    return frozenset(str(item).strip() for item in raw if str(item).strip())
+
+
+def _load_fred_series(catalog_path: Path) -> list[FredSeriesSpec]:
+    if not catalog_path.exists():
+        return []
+    raw = yaml.safe_load(catalog_path.read_text()) or {}
+    rows = raw.get("series") or []
+    specs: list[FredSeriesSpec] = []
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        series_id = str(row.get("id") or "").strip()
+        if not series_id:
+            continue
+        specs.append(
+            FredSeriesSpec(
+                id=series_id,
+                label=str(row.get("label") or series_id),
+                category=str(row.get("category") or "macro"),
+            )
+        )
+    return specs
+
+
+def _spot_fields(
+    raw: dict[str, Any],
+    *,
+    default_pairs: list[str],
+) -> dict[str, Any]:
+    return {
+        "ohlc_interval_minutes": int(raw.get("ohlc_interval_minutes") or 1440),
+        "pairs": [str(p) for p in (raw.get("pairs") or default_pairs)],
+        "retry_backoff_seconds": float(raw.get("retry_backoff_seconds") or 2.0),
+        "max_retries": int(raw.get("max_retries") or 3),
+    }
+
+
+def _kraken_config_from_spot(spot: SpotExchangeConfig) -> KrakenConfig:
+    return KrakenConfig(
+        ohlc_interval_minutes=spot.ohlc_interval_minutes,
+        pairs=list(spot.pairs),
+        retry_backoff_seconds=spot.retry_backoff_seconds,
+        max_retries=spot.max_retries,
+    )
+
+
+def _load_exchanges_config(
+    raw: dict[str, Any],
+    *,
+    kraken_raw: dict[str, Any],
+    ingest_sources: dict[str, bool],
+) -> ExchangesConfig:
+    exchanges_raw = raw.get("exchanges") or {}
+    if exchanges_raw:
+        kr_raw = exchanges_raw.get("kraken") or {}
+        kr_enabled = bool(kr_raw.get("enabled", ingest_sources.get("kraken", True)))
+        cb_raw = exchanges_raw.get("coinbase") or {}
+        cb_enabled = bool(cb_raw.get("enabled", ingest_sources.get("coinbase", False)))
+        primary = str(exchanges_raw.get("primary") or "kraken")
+    else:
+        kr_raw = kraken_raw
+        kr_enabled = bool(ingest_sources.get("kraken", True))
+        cb_raw = {}
+        cb_enabled = bool(ingest_sources.get("coinbase", False))
+        primary = "kraken"
+
+    kraken = SpotExchangeConfig(
+        enabled=kr_enabled,
+        **_spot_fields(kr_raw, default_pairs=["XBTUSD", "ETHUSD"]),
+    )
+    coinbase = SpotExchangeConfig(
+        enabled=cb_enabled,
+        **_spot_fields(cb_raw, default_pairs=["BTC-USD", "ETH-USD"]),
+    )
+    return ExchangesConfig(primary=primary, kraken=kraken, coinbase=coinbase)
+
+
+def _resolve_config_path(path: str | Path | None) -> Path:
+    if path is not None:
+        return Path(path)
+    env_path = os.environ.get("ALLOC_CONTEXT_CONFIG", "").strip()
+    if env_path:
+        return Path(env_path)
+    local = Path("config/config.yaml")
+    if local.exists():
+        return local
+    return Path("config/config.example.yaml")
+
+
+def load_config(path: str | Path | None = None) -> AppConfig:
+    config_path = _resolve_config_path(path)
+    raw: dict[str, Any] = {}
+    if config_path.exists():
+        raw = yaml.safe_load(config_path.read_text()) or {}
+
+    paths_raw = raw.get("paths") or {}
+    horizon_raw = raw.get("horizon") or {}
+    portfolio_raw = raw.get("portfolio") or {}
+    ingest_raw = raw.get("ingest") or {}
+    kraken_raw = raw.get("kraken") or {}
+    kalshi_raw = raw.get("kalshi") or {}
+    macro_raw = raw.get("macro") or {}
+    etf_raw = raw.get("etf") or {}
+    coingecko_raw = raw.get("coingecko") or {}
+    coinmarketcap_raw = raw.get("coinmarketcap") or {}
+    fred_raw = raw.get("fred") or {}
+
+    db_env = os.environ.get("ALLOC_CONTEXT_DB", "").strip()
+    db = _path(db_env or None, str(paths_raw.get("db") or "state/alloccontext.db"))
+
+    kalshi_fallback_tactical = kalshi_raw.get("fallback_tactical_snapshot")
+    kalshi_fallback_state = kalshi_raw.get("fallback_state")
+    kalshi_fallback_daily = kalshi_raw.get("fallback_daily_archive")
+    etf_fallback = etf_raw.get("fallback_snapshot")
+
+    ingest_sources = {
+        str(k): bool(v)
+        for k, v in (ingest_raw.get("sources") or {}).items()
+    }
+    exchanges = _load_exchanges_config(
+        raw,
+        kraken_raw=kraken_raw,
+        ingest_sources=ingest_sources,
+    )
+    kraken = _kraken_config_from_spot(exchanges.kraken)
+
+    return AppConfig(
+        paths=PathsConfig(
+            db=db,
+        ),
+        horizon=HorizonConfig(
+            days=int(horizon_raw.get("days") or 90),
+        ),
+        portfolio=PortfolioConfig(
+            target_allocations=dict(portfolio_raw.get("target_allocations") or {}),
+            rebalance_band=float(portfolio_raw.get("rebalance_band") or 0.15),
+            max_cash_risk_off=float(portfolio_raw.get("max_cash_risk_off") or 0.50),
+            notes=str(portfolio_raw.get("notes") or "").strip(),
+        ),
+        ingest=IngestConfig(
+            interval_minutes=int(ingest_raw.get("interval_minutes") or 60),
+            sources=ingest_sources,
+            optional_sources=_optional_ingest_sources(ingest_raw.get("optional_sources")),
+        ),
+        kraken=kraken,
+        exchanges=exchanges,
+        kalshi=KalshiConfig(
+            use_api=bool(kalshi_raw.get("use_api", True)),
+            base_url=_validate_kalshi_base_url(
+                str(
+                    kalshi_raw.get("base_url")
+                    or "https://api.elections.kalshi.com/trade-api/v2"
+                )
+            ),
+            timeout_seconds=float(kalshi_raw.get("timeout_seconds") or 20.0),
+            cf_history_max_age_minutes=int(kalshi_raw.get("cf_history_max_age_minutes") or 90),
+            series=[
+                KalshiSeriesConfig(
+                    asset=str(row.get("asset") or ""),
+                    series=str(row.get("series") or ""),
+                    cf_index=str(row.get("cf_index") or ""),
+                )
+                for row in (kalshi_raw.get("series") or [])
+                if isinstance(row, dict) and row.get("series")
+            ]
+            or [
+                KalshiSeriesConfig(asset="BTC", series="KXBTCD", cf_index="BRTI"),
+                KalshiSeriesConfig(asset="ETH", series="KXETHD", cf_index="ETHUSD_RTI"),
+            ],
+            fallback_tactical_snapshot=(
+                Path(kalshi_fallback_tactical) if kalshi_fallback_tactical else None
+            ),
+            fallback_state=(
+                Path(kalshi_fallback_state) if kalshi_fallback_state else None
+            ),
+            fallback_daily_archive=(
+                Path(kalshi_fallback_daily) if kalshi_fallback_daily else None
+            ),
+        ),
+        rollup=load_rollup_config(raw),
+        macro=MacroConfig(
+            static_calendar=_path(
+                str(macro_raw.get("static_calendar") or "config/macro-calendar.yaml"),
+                "config/macro-calendar.yaml",
+            ),
+            countries=[str(c).upper() for c in (macro_raw.get("countries") or ["US"])],
+            min_impact=str(macro_raw.get("min_impact") or "medium").lower(),
+            fetch_past_days=int(macro_raw.get("fetch_past_days") or 7),
+            fetch_future_days=int(macro_raw.get("fetch_future_days") or 28),
+            finnhub_enabled=bool(macro_raw.get("finnhub_enabled", True)),
+            fmp_enabled=bool(macro_raw.get("fmp_enabled", False)),
+            timeout_seconds=float(macro_raw.get("timeout_seconds") or 20.0),
+        ),
+        etf=EtfConfig(
+            assets=[str(a).upper() for a in (etf_raw.get("assets") or ["BTC", "ETH"])],
+            sosovalue_enabled=bool(etf_raw.get("sosovalue_enabled", True)),
+            fallback_snapshot=Path(etf_fallback) if etf_fallback else None,
+            timeout_seconds=float(etf_raw.get("timeout_seconds") or 20.0),
+        ),
+        coingecko=CoingeckoConfig(
+            coin_ids=[str(c) for c in (coingecko_raw.get("coin_ids") or ["bitcoin", "ethereum"])],
+            use_demo_key=bool(coingecko_raw.get("use_demo_key", True)),
+            timeout_seconds=float(coingecko_raw.get("timeout_seconds") or 20.0),
+        ),
+        coinmarketcap=CoinmarketcapConfig(
+            symbols=[str(s).upper() for s in (coinmarketcap_raw.get("symbols") or ["BTC", "ETH"])],
+            timeout_seconds=float(coinmarketcap_raw.get("timeout_seconds") or 20.0),
+        ),
+        fred=FredConfig(
+            series=_load_fred_series(
+                _path(
+                    str(fred_raw.get("series_catalog") or "config/fred-series.yaml"),
+                    "config/fred-series.yaml",
+                )
+            ),
+            lookback_days=int(fred_raw.get("lookback_days") or 120),
+            timeout_seconds=float(fred_raw.get("timeout_seconds") or 20.0),
+        ),
+    )

alloccontext/horizon.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+QUARTERLY_DAYS = 90
+
+
+def horizon_days(config) -> int:
+    return int(getattr(config.horizon, "days", QUARTERLY_DAYS))
+
+
+def cutoff_unix(*, days: int, now: datetime | None = None) -> int:
+    now = now or datetime.now(timezone.utc)
+    return int((now - timedelta(days=max(1, days))).timestamp())
+
+
+def cutoff_iso(*, days: int, now: datetime | None = None) -> str:
+    now = now or datetime.now(timezone.utc)
+    at = (now - timedelta(days=max(1, days))).replace(microsecond=0)
+    return at.isoformat()
+
+
+def bars_within_horizon(
+    bars: list[dict[str, float]],
+    *,
+    days: int,
+    now: datetime | None = None,
+) -> list[dict[str, float]]:
+    floor = cutoff_unix(days=days, now=now)
+    return [bar for bar in bars if int(bar["time"]) >= floor]

alloccontext/ingest/__init__.py

@@ -0,0 +1 @@
+"""Data source ingestors. See docs/data-sources.md."""

alloccontext/ingest/cf_benchmarks.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import re
+import urllib.error
+import urllib.request
+
+CF_BENCHMARKS_BASE = "https://www.cfbenchmarks.com/data/indices"
+_USER_AGENT = "Mozilla/5.0 (compatible; alloc-context/0.1)"
+_VALUE_PATTERN = re.compile(r'"value"\s*:\s*"?([0-9.]+)')
+
+
+class CFBenchmarksPriceError(RuntimeError):
+    pass
+
+
+def parse_index_value(html: str) -> float:
+    match = _VALUE_PATTERN.search(html)
+    if not match:
+        raise CFBenchmarksPriceError("Could not parse CF Benchmarks index value")
+    return float(match.group(1))
+
+
+def fetch_index_price(index: str, *, timeout: float = 20.0) -> float:
+    url = f"{CF_BENCHMARKS_BASE}/{index}"
+    request = urllib.request.Request(url, headers={"User-Agent": _USER_AGENT})
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            html = response.read().decode("utf-8", errors="replace")
+    except (urllib.error.URLError, TimeoutError) as exc:
+        raise CFBenchmarksPriceError(f"CF Benchmarks fetch failed for {index}: {exc}") from exc
+    return parse_index_value(html)
+
+
+def fetch_prices(indices: list[str], *, timeout: float = 20.0) -> dict[str, float]:
+    out: dict[str, float] = {}
+    for index in indices:
+        out[index] = fetch_index_price(index, timeout=timeout)
+    return out

alloccontext/ingest/cf_history.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import datetime as dt
+import json
+import sqlite3
+from typing import Any
+
+from alloccontext.store.meta import get_meta, set_meta
+
+CF_HISTORY_META_KEY = "cf_price_history"
+
+
+def _parse_ts(raw: str | None) -> dt.datetime | None:
+    if not raw:
+        return None
+    try:
+        parsed = dt.datetime.fromisoformat(raw.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=dt.timezone.utc)
+    return parsed.astimezone(dt.timezone.utc)
+
+
+def load_cf_history(conn: sqlite3.Connection) -> dict[str, list[dict[str, Any]]]:
+    raw = get_meta(conn, CF_HISTORY_META_KEY)
+    if not raw:
+        return {}
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError:
+        return {}
+    if not isinstance(parsed, dict):
+        return {}
+    return {
+        str(key): [row for row in rows if isinstance(row, dict)]
+        for key, rows in parsed.items()
+        if isinstance(rows, list)
+    }
+
+
+def save_cf_history(conn: sqlite3.Connection, history: dict[str, list[dict[str, Any]]]) -> None:
+    set_meta(conn, CF_HISTORY_META_KEY, json.dumps(history))
+
+
+def record_cf_price_samples(
+    history: dict[str, list[dict[str, Any]]] | None,
+    prices: dict[str, float],
+    now: dt.datetime,
+    *,
+    max_age_minutes: float,
+) -> dict[str, list[dict[str, Any]]]:
+    out = {key: list(rows) for key, rows in (history or {}).items()}
+    cutoff = now.astimezone(dt.timezone.utc) - dt.timedelta(minutes=max_age_minutes)
+    stamp = now.astimezone(dt.timezone.utc).replace(microsecond=0).isoformat()
+    for index, price in prices.items():
+        rows = list(out.get(index) or [])
+        rows.append({"at": stamp, "price": float(price)})
+        kept: list[dict[str, Any]] = []
+        for row in rows:
+            ts = _parse_ts(row.get("at"))
+            if ts is not None and ts >= cutoff:
+                kept.append(row)
+        out[index] = kept
+    return out