alloc-context 0.1.0__py3-none-any.whl

alloccontext/ingest/macro_normalize.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+from typing import Any
+from zoneinfo import ZoneInfo
+
+_IMPACT_RANK = {"low": 1, "medium": 2, "high": 3}
+
+
+def normalize_impact(value: str | None) -> str:
+    if not value:
+        return "medium"
+    cleaned = str(value).strip().lower()
+    if cleaned in _IMPACT_RANK:
+        return cleaned
+    if cleaned in {"1", "2", "3"}:
+        return {1: "low", 2: "medium", 3: "high"}[int(cleaned)]
+    return "medium"
+
+
+def impact_meets_minimum(impact: str, minimum: str) -> bool:
+    return _IMPACT_RANK.get(impact, 2) >= _IMPACT_RANK.get(minimum, 2)
+
+
+def slug_event_name(name: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+    return slug[:80] or "event"
+
+
+def calendar_row_date_time(
+    item: dict[str, Any],
+    *,
+    date_key: str = "date",
+    time_key: str = "time",
+) -> tuple[str, str] | None:
+    """Extract (YYYY-MM-DD, HH:MM:SS) from calendar API rows.
+
+    Finnhub live payloads often use a combined ``time`` field
+    (``2026-05-21 12:30:00``) without a separate ``date`` key.
+    """
+    raw_date = str(item.get(date_key) or "").strip()
+    raw_time = str(item.get(time_key) or "").strip()
+    if raw_date:
+        return raw_date[:10], raw_time or "00:00:00"
+    if not raw_time:
+        return None
+    if " " in raw_time:
+        date_part, clock = raw_time.split(" ", 1)
+        return date_part.strip()[:10], clock.strip()
+    return None
+
+
+def parse_event_ts(
+    *,
+    date: str,
+    time: str | None,
+    tz_name: str,
+) -> str:
+    """Return UTC ISO timestamp for a calendar date + local time."""
+    local_tz = ZoneInfo(tz_name)
+    time_part = (time or "00:00:00").strip()
+    if len(time_part) == 5:
+        time_part = f"{time_part}:00"
+    local = datetime.fromisoformat(f"{date}T{time_part}").replace(tzinfo=local_tz)
+    return local.astimezone(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def normalized_event(
+    *,
+    source: str,
+    country: str,
+    name: str,
+    event_ts: str,
+    impact: str,
+    category: str | None = None,
+    actual: Any = None,
+    estimate: Any = None,
+    previous: Any = None,
+    unit: str | None = None,
+    raw: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    impact_norm = normalize_impact(impact)
+    event_id = f"{source}:{event_ts[:10]}:{slug_event_name(name)}"
+    return {
+        "event_id": event_id,
+        "event_ts": event_ts,
+        "country": country.upper(),
+        "name": name.strip(),
+        "impact": impact_norm,
+        "category": category,
+        "actual": actual,
+        "estimate": estimate,
+        "previous": previous,
+        "unit": unit,
+        "source": source,
+        "raw": raw or {},
+    }

alloccontext/ingest/market_snapshots.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timezone
+from typing import Any
+
+
+def upsert_crypto_market_snapshot(
+    conn: sqlite3.Connection,
+    *,
+    source: str,
+    snapshot_ts: str,
+    snapshot: dict[str, Any],
+) -> None:
+    fetched_at = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+    conn.execute(
+        """
+        INSERT INTO crypto_market_snapshots(
+          snapshot_ts, source, total_market_cap_usd, btc_dominance_pct,
+          eth_dominance_pct, btc_rank, eth_rank, btc_price_usd, eth_price_usd,
+          btc_market_cap_usd, eth_market_cap_usd, btc_change_pct_24h,
+          eth_change_pct_24h, fetched_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(source, snapshot_ts) DO UPDATE SET
+          total_market_cap_usd = excluded.total_market_cap_usd,
+          btc_dominance_pct = excluded.btc_dominance_pct,
+          eth_dominance_pct = excluded.eth_dominance_pct,
+          btc_rank = excluded.btc_rank,
+          eth_rank = excluded.eth_rank,
+          btc_price_usd = excluded.btc_price_usd,
+          eth_price_usd = excluded.eth_price_usd,
+          btc_market_cap_usd = excluded.btc_market_cap_usd,
+          eth_market_cap_usd = excluded.eth_market_cap_usd,
+          btc_change_pct_24h = excluded.btc_change_pct_24h,
+          eth_change_pct_24h = excluded.eth_change_pct_24h,
+          fetched_at = excluded.fetched_at
+        """,
+        (
+            snapshot_ts,
+            source,
+            snapshot.get("total_market_cap_usd"),
+            snapshot.get("btc_dominance_pct"),
+            snapshot.get("eth_dominance_pct"),
+            snapshot.get("btc_rank"),
+            snapshot.get("eth_rank"),
+            snapshot.get("btc_price_usd"),
+            snapshot.get("eth_price_usd"),
+            snapshot.get("btc_market_cap_usd"),
+            snapshot.get("eth_market_cap_usd"),
+            snapshot.get("btc_change_pct_24h"),
+            snapshot.get("eth_change_pct_24h"),
+            fetched_at,
+        ),
+    )
+
+
+def latest_snapshot(conn: sqlite3.Connection, source: str):
+    return conn.execute(
+        """
+        SELECT *
+        FROM crypto_market_snapshots
+        WHERE source = ?
+        ORDER BY snapshot_ts DESC
+        LIMIT 1
+        """,
+        (source,),
+    ).fetchone()
+
+
+def prior_snapshot(conn: sqlite3.Connection, source: str, before_ts: str):
+    return conn.execute(
+        """
+        SELECT *
+        FROM crypto_market_snapshots
+        WHERE source = ? AND snapshot_ts < ?
+        ORDER BY snapshot_ts DESC
+        LIMIT 1
+        """,
+        (source, before_ts),
+    ).fetchone()
+
+
+def row_to_dict(row) -> dict[str, Any]:
+    if row is None:
+        return {}
+    return {
+        "snapshot_ts": row["snapshot_ts"],
+        "source": row["source"],
+        "total_market_cap_usd": row["total_market_cap_usd"],
+        "btc_dominance_pct": row["btc_dominance_pct"],
+        "eth_dominance_pct": row["eth_dominance_pct"],
+        "btc_rank": row["btc_rank"],
+        "eth_rank": row["eth_rank"],
+        "btc_price_usd": row["btc_price_usd"],
+        "eth_price_usd": row["eth_price_usd"],
+        "btc_market_cap_usd": row["btc_market_cap_usd"],
+        "eth_market_cap_usd": row["eth_market_cap_usd"],
+        "btc_change_pct_24h": row["btc_change_pct_24h"],
+        "eth_change_pct_24h": row["eth_change_pct_24h"],
+    }
+
+
+def dominance_delta(current: dict[str, Any], prior: dict[str, Any]) -> dict[str, float | None]:
+    out: dict[str, float | None] = {}
+    for key in ("btc_dominance_pct", "eth_dominance_pct"):
+        cur = current.get(key)
+        prev = prior.get(key)
+        if cur is None or prev is None:
+            out[key.replace("_pct", "_change")] = None
+        else:
+            out[key.replace("_pct", "_change")] = round(float(cur) - float(prev), 4)
+    return out

alloccontext/ingest/outcome.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def normalize_optional_feed_name(feed: str) -> str:
+    """Map per-asset SoSoValue feed keys to the configured optional source name."""
+    if feed.startswith("sosovalue_"):
+        return "sosovalue"
+    return feed
+
+
+def skipped_source_error(
+    source: str,
+    result: dict[str, Any],
+    optional_sources: frozenset[str],
+) -> str | None:
+    """Map required-source skips to ingest errors."""
+    if not result.get("skipped"):
+        return None
+    if source in optional_sources:
+        return None
+    reason = str(result.get("reason") or "skipped")
+    if reason in {"exchange_disabled", "not_implemented"}:
+        return None
+    return reason
+
+
+def optional_feed_errors(
+    result: dict[str, Any],
+    optional_sources: frozenset[str],
+) -> dict[str, str]:
+    errors: dict[str, str] = {}
+    for feed, message in (result.get("feed_errors") or {}).items():
+        name = normalize_optional_feed_name(str(feed))
+        if name in optional_sources:
+            errors[name] = str(message)
+    return errors
+
+
+def ingest_errors_from_source(
+    source: str,
+    result: dict[str, Any],
+    optional_sources: frozenset[str],
+) -> dict[str, str]:
+    """Collect per-source and optional-feed errors for ingest outcome classification."""
+    skip_error = skipped_source_error(source, result, optional_sources)
+    if skip_error:
+        return {source: skip_error}
+
+    feed_optional = optional_feed_errors(result, optional_sources)
+
+    if result.get("ok") or result.get("skipped"):
+        return feed_optional
+
+    if source in optional_sources:
+        errors = {source: str(result.get("error") or "failed")}
+        errors.update(feed_optional)
+        return errors
+
+    # Parent failed: only optional feeds failed — do not fail ingest on the parent.
+    if feed_optional and not any(
+        normalize_optional_feed_name(str(feed)) not in optional_sources
+        for feed in (result.get("feed_errors") or {})
+    ):
+        return feed_optional
+
+    errors = {source: str(result.get("error") or "failed")}
+    errors.update(feed_optional)
+    return errors
+
+
+def classify_ingest_errors(
+    errors: dict[str, str],
+    optional_sources: frozenset[str],
+) -> tuple[dict[str, str], dict[str, str]]:
+    """Split failures into required (fatal) vs optional (non-fatal)."""
+    fatal: dict[str, str] = {}
+    optional: dict[str, str] = {}
+    for source, message in errors.items():
+        if source in optional_sources:
+            optional[source] = message
+        else:
+            fatal[source] = message
+    return fatal, optional
+
+
+def ingest_ok(
+    errors: dict[str, str],
+    optional_sources: frozenset[str],
+) -> tuple[bool, bool]:
+    fatal, optional = classify_ingest_errors(errors, optional_sources)
+    ok = not fatal
+    partial = ok and bool(optional)
+    return ok, partial
+
+
+def summarize_ingest_outcome(
+    errors: dict[str, str],
+    optional_sources: frozenset[str],
+) -> dict[str, Any]:
+    fatal, optional = classify_ingest_errors(errors, optional_sources)
+    ok, partial = ingest_ok(errors, optional_sources)
+    return {
+        "ok": ok,
+        "partial": partial,
+        "errors": errors,
+        "fatal_errors": fatal,
+        "optional_errors": optional,
+    }

alloccontext/ingest/parse_helpers.py

@@ -0,0 +1,23 @@
+"""Shared parsing helpers for ingest API responses."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def parse_float(value: Any) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def parse_int(value: Any) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None

alloccontext/ingest/runner.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timezone
+from typing import Any
+
+from alloccontext.horizon import horizon_days
+from alloccontext.ingest.outcome import (
+    ingest_errors_from_source,
+    optional_feed_errors,
+    summarize_ingest_outcome,
+)
+from alloccontext.ingest.coingecko import refresh_coingecko
+from alloccontext.ingest.coinmarketcap import refresh_coinmarketcap
+from alloccontext.ingest.etf_flows import refresh_etf_flows
+from alloccontext.ingest.fred import refresh_fred
+from alloccontext.ingest.fear_greed import refresh_fear_greed
+from alloccontext.ingest.kalshi import refresh_kalshi
+from alloccontext.ingest.coinbase_portfolio import refresh_coinbase
+from alloccontext.ingest.kraken_portfolio import refresh_kraken
+from alloccontext.ingest.macro_calendar import refresh_macro_calendar
+from alloccontext.store.db import record_ingest_run
+from alloccontext.store.retention import prune_to_horizon
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def _run_source(
+    conn: sqlite3.Connection,
+    config,
+    source: str,
+) -> dict[str, Any]:
+    started = _now_iso()
+    if source == "fear_greed":
+        result = refresh_fear_greed(conn, history_limit=horizon_days(config))
+    elif source == "kraken":
+        result = refresh_kraken(conn, config)
+    elif source == "coinbase":
+        result = refresh_coinbase(conn, config)
+    elif source == "kalshi":
+        result = refresh_kalshi(conn, config)
+    elif source == "macro_calendar":
+        result = refresh_macro_calendar(conn, config)
+    elif source == "etf_flows":
+        result = refresh_etf_flows(conn, config)
+    elif source == "coingecko":
+        result = refresh_coingecko(conn, config)
+    elif source == "coinmarketcap":
+        result = refresh_coinmarketcap(conn, config)
+    elif source == "fred":
+        result = refresh_fred(conn, config)
+    else:
+        result = {"ok": False, "rows": 0, "error": f"unknown_source:{source}"}
+
+    finished = _now_iso()
+    rows = int(result.get("rows") or 0)
+    source_errors = ingest_errors_from_source(
+        source,
+        result,
+        config.ingest.optional_sources,
+    )
+    parent_error = source_errors.get(source)
+    record_ingest_run(
+        conn,
+        source=source,
+        started_at=started,
+        finished_at=finished,
+        rows_upserted=rows,
+        error=parent_error,
+    )
+    for feed_name, message in optional_feed_errors(
+        result, config.ingest.optional_sources
+    ).items():
+        record_ingest_run(
+            conn,
+            source=feed_name,
+            started_at=started,
+            finished_at=finished,
+            rows_upserted=0,
+            error=message,
+        )
+    return result
+
+
+def run_ingest(
+    conn: sqlite3.Connection,
+    config,
+    *,
+    dry_run: bool = False,
+) -> dict[str, Any]:
+    """Pull enabled sources into SQLite."""
+    counts: dict[str, int] = {}
+    results: dict[str, Any] = {}
+    errors: dict[str, str] = {}
+
+    for source, enabled in config.ingest.sources.items():
+        if not enabled:
+            counts[source] = 0
+            continue
+        if dry_run:
+            counts[source] = 0
+            results[source] = {"ok": True, "dry_run": True}
+            continue
+        result = _run_source(conn, config, source)
+        results[source] = result
+        counts[source] = int(result.get("rows") or 0)
+        errors.update(
+            ingest_errors_from_source(
+                source,
+                result,
+                config.ingest.optional_sources,
+            )
+        )
+
+    outcome = summarize_ingest_outcome(errors, config.ingest.optional_sources)
+    pruned: dict[str, int] = {}
+    snapshots: dict[str, str] = {}
+    if not dry_run:
+        pruned = prune_to_horizon(conn, config)
+        if not outcome["fatal_errors"]:
+            from alloccontext.rollup.context import Scope, build_context_bundle
+
+            for scope in ("daily", "weekly"):
+                scope_lit: Scope = scope  # type: ignore[assignment]
+                bundle = build_context_bundle(
+                    conn,
+                    config,
+                    scope=scope_lit,
+                    rollup=config.rollup,
+                    save_snapshot=True,
+                )
+                snapshots[scope] = bundle["as_of"]
+
+    return {
+        "counts": counts,
+        "results": results,
+        "errors": outcome["errors"],
+        "fatal_errors": outcome["fatal_errors"],
+        "optional_errors": outcome["optional_errors"],
+        "pruned": pruned,
+        "snapshots": snapshots,
+        "dry_run": dry_run,
+        "ok": outcome["ok"],
+        "partial": outcome["partial"],
+        "horizon_days": horizon_days(config),
+    }

alloccontext/mcp/__init__.py

@@ -0,0 +1 @@
+"""AllocContext MCP server (stdio)."""

alloccontext/mcp/assets.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from typing import Any
+
+DEFAULT_VIEW_ASSETS: tuple[str, ...] = ("BTC", "ETH")
+ALLOCATION_ASSETS: tuple[str, ...] = ("BTC", "ETH", "CASH")
+_SYMBOL_BY_ASSET = {"BTC": "btc", "ETH": "eth", "CASH": "cash"}
+
+
+def validate_view_assets(assets: list[str] | None) -> tuple[str, ...]:
+    if assets is None or len(assets) == 0:
+        return DEFAULT_VIEW_ASSETS
+    normalized: list[str] = []
+    seen: set[str] = set()
+    for raw in assets:
+        key = str(raw).strip().upper()
+        if not key:
+            continue
+        if key not in ALLOCATION_ASSETS:
+            raise ValueError(
+                f"unsupported asset {raw!r}; allowed: {', '.join(ALLOCATION_ASSETS)}"
+            )
+        if key not in seen:
+            normalized.append(key)
+            seen.add(key)
+    if not normalized:
+        return DEFAULT_VIEW_ASSETS
+    return tuple(normalized)
+
+
+def _asset_symbols(assets: tuple[str, ...]) -> set[str]:
+    return {_SYMBOL_BY_ASSET[asset] for asset in assets if asset in _SYMBOL_BY_ASSET}
+
+
+def filter_market_assets(market: dict[str, Any], assets: tuple[str, ...]) -> dict[str, Any]:
+    if not market.get("available"):
+        return market
+    symbols = _asset_symbols(assets)
+    block = market.get("assets")
+    if not isinstance(block, dict) or not symbols:
+        return market
+    filtered = {
+        key: value for key, value in block.items() if key.lower() in symbols
+    }
+    result = dict(market)
+    if filtered:
+        result["assets"] = filtered
+    else:
+        result["available"] = False
+        result["reason"] = "no_market_data_for_requested_assets"
+        result.pop("assets", None)
+    return result
+
+
+def filter_etf_block(etf: dict[str, Any], assets: tuple[str, ...]) -> dict[str, Any]:
+    if not etf.get("available"):
+        return etf
+    block = etf.get("assets")
+    if not isinstance(block, dict):
+        return etf
+    wanted = {asset for asset in assets if asset in ("BTC", "ETH")}
+    if not wanted:
+        return etf
+    filtered = {key: value for key, value in block.items() if key.upper() in wanted}
+    result = dict(etf)
+    if filtered:
+        result["assets"] = filtered
+    else:
+        result["available"] = False
+        result["reason"] = "no_etf_data_for_requested_assets"
+        result.pop("assets", None)
+    return result
+
+
+def filter_delta_market(delta: dict[str, Any], assets: tuple[str, ...]) -> dict[str, Any]:
+    if not delta.get("available"):
+        return delta
+    symbols = _asset_symbols(assets)
+    shifts = [
+        line
+        for line in delta.get("notable_shifts") or []
+        if any(symbol.upper() in line for symbol in symbols)
+        or "Portfolio" in line
+        or "F&G" in line
+    ]
+    result = dict(delta)
+    result["notable_shifts"] = shifts
+    market = delta.get("market")
+    if not isinstance(market, dict):
+        return result
+    filtered_market = {
+        key: value
+        for key, value in market.items()
+        if any(symbol in key for symbol in symbols)
+    }
+    if filtered_market:
+        result["market"] = filtered_market
+    else:
+        result.pop("market", None)
+    return result
+
+
+def filter_macro_etf(macro: dict[str, Any], assets: tuple[str, ...]) -> dict[str, Any]:
+    etf = macro.get("etf")
+    if not isinstance(etf, dict):
+        return macro
+    wanted = {asset for asset in assets if asset in ("BTC", "ETH")}
+    if not wanted:
+        return macro
+    filtered = {key: value for key, value in etf.items() if key.upper() in wanted}
+    result = dict(macro)
+    if filtered:
+        result["etf"] = filtered
+    else:
+        result.pop("etf", None)
+    return result
+
+
+def apply_assets_filter_to_bundle(
+    bundle: dict[str, Any],
+    assets: tuple[str, ...],
+) -> dict[str, Any]:
+    result = dict(bundle)
+    result["assets"] = list(assets)
+    if "market" in result:
+        result["market"] = filter_market_assets(result["market"], assets)
+    if "macro" in result and isinstance(result["macro"], dict):
+        result["macro"] = filter_macro_etf(result["macro"], assets)
+    if "delta" in result:
+        result["delta"] = filter_delta_market(result["delta"], assets)
+    return result
+
+
+def apply_assets_filter_to_market_payload(
+    payload: dict[str, Any],
+    assets: tuple[str, ...],
+) -> dict[str, Any]:
+    result = dict(payload)
+    result["assets"] = list(assets)
+    if isinstance(result.get("etf"), dict):
+        result["etf"] = filter_etf_block(result["etf"], assets)
+    if isinstance(result.get("breadth"), dict) and isinstance(
+        result["breadth"].get("assets"), dict
+    ):
+        symbols = _asset_symbols(assets)
+        breadth = dict(result["breadth"])
+        breadth["assets"] = {
+            key: value
+            for key, value in breadth["assets"].items()
+            if key.lower() in symbols
+        }
+        result["breadth"] = breadth
+    return result