alloc-context 0.1.0__py3-none-any.whl

alloccontext/rollup/context.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timezone
+from typing import Any, Literal
+
+from alloccontext.store.jsonutil import canonical_json
+
+from alloccontext.rollup.cluster_config import RollupConfig, load_rollup_config
+from alloccontext.rollup.delta import build_delta_context
+from alloccontext.rollup.macro import build_macro_context
+from alloccontext.rollup.portfolio import build_market_context, build_portfolio_context
+from alloccontext.rollup.regime import build_regime_context
+from alloccontext.rollup.sentiment import build_sentiment_context
+
+Scope = Literal["daily", "weekly"]
+
+
+def _load_prior_context(
+    conn: sqlite3.Connection,
+    *,
+    scope: Scope,
+    prior_as_of: str | None,
+) -> dict[str, Any] | None:
+    if not prior_as_of:
+        return None
+    row = conn.execute(
+        """
+        SELECT context_json FROM context_snapshots
+        WHERE scope = ? AND as_of = ?
+        """,
+        (scope, prior_as_of),
+    ).fetchone()
+    if row is None:
+        return None
+    try:
+        return json.loads(row["context_json"])
+    except (TypeError, json.JSONDecodeError):
+        return None
+
+
+def _save_context_snapshot(
+    conn: sqlite3.Connection,
+    *,
+    scope: Scope,
+    as_of: str,
+    context: dict[str, Any],
+) -> None:
+    conn.execute(
+        """
+        INSERT INTO context_snapshots(scope, as_of, context_json)
+        VALUES (?, ?, ?)
+        ON CONFLICT(scope, as_of) DO UPDATE SET
+          context_json = excluded.context_json
+        """,
+        (scope, as_of, canonical_json(context)),
+    )
+    conn.commit()
+
+
+def build_context_bundle(
+    conn,
+    config,
+    *,
+    scope: Scope,
+    rollup: RollupConfig,
+    as_of: datetime | None = None,
+    save_snapshot: bool = False,
+) -> dict[str, Any]:
+    now = (as_of or datetime.now(timezone.utc)).replace(microsecond=0)
+
+    prior_row = conn.execute(
+        """
+        SELECT as_of FROM context_snapshots
+        WHERE scope = ? AND as_of < ?
+        ORDER BY as_of DESC LIMIT 1
+        """,
+        (scope, now.isoformat()),
+    ).fetchone()
+    prior_as_of = prior_row["as_of"] if prior_row else None
+    prior_context = _load_prior_context(conn, scope=scope, prior_as_of=prior_as_of)
+
+    portfolio = build_portfolio_context(conn, config)
+    market = build_market_context(conn, config)
+    sentiment = build_sentiment_context(conn, config, rollup, now=now)
+    macro = build_macro_context(conn, config, now=now, scope=scope)
+    delta = build_delta_context(
+        conn,
+        now=now,
+        portfolio=portfolio,
+        sentiment=sentiment,
+        market=market,
+        prior_context=prior_context,
+    )
+
+    bundle = {
+        "bundle_id": f"{scope}:{now.isoformat()}",
+        "scope": scope,
+        "as_of": now.isoformat(),
+        "prior_as_of": prior_as_of,
+        "horizon_days": config.horizon.days,
+        "portfolio": portfolio,
+        "market": market,
+        "sentiment": sentiment,
+        "macro": macro,
+        "delta": delta,
+        "regime": build_regime_context(
+            portfolio=portfolio,
+            sentiment=sentiment,
+            delta=delta,
+            prior_as_of=prior_as_of,
+            max_cash_risk_off=config.portfolio.max_cash_risk_off,
+        ),
+    }
+    if save_snapshot:
+        _save_context_snapshot(conn, scope=scope, as_of=bundle["as_of"], context=bundle)
+    return bundle

alloccontext/rollup/delta.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+
+def _asset_price(context: dict[str, Any] | None, symbol: str) -> float | None:
+    if not context:
+        return None
+    market = context.get("market") or {}
+    if not market.get("available"):
+        return None
+    assets = market.get("assets") or {}
+    block = assets.get(symbol.lower()) or assets.get(symbol)
+    if not isinstance(block, dict):
+        return None
+    price = block.get("price_usd")
+    return float(price) if price is not None else None
+
+
+def _pct_change(current: float | None, prior: float | None) -> float | None:
+    if current is None or prior is None or prior == 0:
+        return None
+    return round((current - prior) / prior * 100, 2)
+
+
+def build_delta_context(
+    conn: sqlite3.Connection,
+    *,
+    now: datetime,
+    portfolio: dict[str, Any],
+    sentiment: dict[str, Any],
+    market: dict[str, Any],
+    prior_context: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    delta: dict[str, Any] = {"available": True, "notable_shifts": []}
+
+    fg = sentiment.get("fear_greed") if sentiment.get("available") else None
+    if fg:
+        prior_fg_value = None
+        if prior_context:
+            prior_sentiment = prior_context.get("sentiment") or {}
+            prior_fg = prior_sentiment.get("fear_greed") or {}
+            if prior_fg.get("value") is not None:
+                prior_fg_value = int(prior_fg["value"])
+        if prior_fg_value is None:
+            from alloccontext.rollup.fear_greed import fear_greed_at_or_before
+
+            day_ago = int((now - timedelta(days=1)).timestamp())
+            prior_row = fear_greed_at_or_before(conn, at_ts=day_ago)
+            if prior_row:
+                prior_fg_value = int(prior_row["value"])
+
+        if prior_fg_value is not None:
+            change = int(fg["value"]) - prior_fg_value
+            delta["fear_greed_change"] = change
+            if abs(change) >= 5:
+                delta["notable_shifts"].append(
+                    f"F&G {prior_fg_value} → {fg['value']} ({change:+d})"
+                )
+
+    if portfolio.get("available"):
+        nav = portfolio.get("nav_usd")
+        prior_nav = None
+        if prior_context:
+            prior_portfolio = prior_context.get("portfolio") or {}
+            if prior_portfolio.get("nav_usd") is not None:
+                prior_nav = float(prior_portfolio["nav_usd"])
+        if prior_nav is not None and nav is not None:
+            pnl = round(float(nav) - prior_nav, 2)
+            delta["portfolio_nav_change_usd"] = pnl
+            if abs(pnl) >= 100:
+                delta["notable_shifts"].append(
+                    f"Portfolio Δ ${pnl:+.2f} since prior snapshot"
+                )
+        else:
+            pnl = (portfolio.get("pnl_usd") or {}).get("since_prior_snapshot")
+            if pnl is not None:
+                delta["portfolio_nav_change_usd"] = pnl
+                if abs(float(pnl)) >= 100:
+                    delta["notable_shifts"].append(
+                        f"Portfolio Δ ${pnl:+.2f} vs prior snapshot"
+                    )
+
+    market_changes: dict[str, float | None] = {}
+    for symbol in ("btc", "eth"):
+        current = _asset_price(market, symbol)
+        prior = _asset_price(prior_context, symbol)
+        change = _pct_change(current, prior)
+        if change is not None:
+            market_changes[f"{symbol}_change_pct_since_prior"] = change
+            if abs(change) >= 2:
+                delta["notable_shifts"].append(
+                    f"{symbol.upper()} {change:+.2f}% since prior snapshot"
+                )
+    if market_changes:
+        delta["market"] = market_changes
+
+    if not delta.get("notable_shifts"):
+        has_metrics = (
+            delta.get("fear_greed_change") is not None
+            or delta.get("portfolio_nav_change_usd") is not None
+            or bool(market_changes)
+        )
+        if not has_metrics:
+            delta["available"] = False
+
+    return delta

alloccontext/rollup/etf.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Literal
+
+Scope = Literal["daily", "weekly"]
+
+
+def _sum_flows(rows) -> float | None:
+    values = [float(row["net_flow_usd"]) for row in rows if row["net_flow_usd"] is not None]
+    if not values:
+        return None
+    return round(sum(values), 2)
+
+
+def _latest_flow_row(conn, asset: str):
+    return conn.execute(
+        """
+        SELECT flow_date, net_flow_usd, total_net_assets_usd, cum_net_inflow_usd, source
+        FROM etf_flow_days
+        WHERE asset = ?
+        ORDER BY flow_date DESC
+        LIMIT 1
+        """,
+        (asset,),
+    ).fetchone()
+
+
+def _flows_since(conn, asset: str, since_date: str) -> list:
+    return conn.execute(
+        """
+        SELECT flow_date, net_flow_usd
+        FROM etf_flow_days
+        WHERE asset = ? AND flow_date >= ?
+        ORDER BY flow_date ASC
+        """,
+        (asset, since_date),
+    ).fetchall()
+
+
+def _ticker_breakdown(conn, asset: str, flow_date: str | None) -> dict[str, float]:
+    if not flow_date:
+        return {}
+    rows = conn.execute(
+        """
+        SELECT ticker, net_flow_usd
+        FROM etf_ticker_flows
+        WHERE asset = ? AND flow_date = ?
+        ORDER BY ABS(COALESCE(net_flow_usd, 0)) DESC
+        """,
+        (asset, flow_date),
+    ).fetchall()
+    out: dict[str, float] = {}
+    for row in rows:
+        if row["net_flow_usd"] is None:
+            continue
+        out[str(row["ticker"])] = round(float(row["net_flow_usd"]), 2)
+    return out
+
+
+def build_etf_asset_context(conn, *, asset: str, now: datetime, scope: Scope) -> dict[str, Any]:
+    latest = _latest_flow_row(conn, asset)
+    if latest is None:
+        return {"available": False, "reason": "no_data"}
+
+    window_days = 1 if scope == "daily" else 7
+    since = (now.date() - timedelta(days=window_days - 1)).isoformat()
+    window_rows = _flows_since(conn, asset, since)
+    net_window = _sum_flows(window_rows)
+
+    result: dict[str, Any] = {
+        "available": True,
+        "as_of_date": latest["flow_date"],
+        "source": latest["source"],
+        "net_flow_usd_1d": (
+            round(float(latest["net_flow_usd"]), 2)
+            if latest["net_flow_usd"] is not None
+            else None
+        ),
+        "net_flow_usd_7d": net_window if scope == "weekly" else _sum_flows(_flows_since(
+            conn,
+            asset,
+            (now.date() - timedelta(days=6)).isoformat(),
+        )),
+        "total_net_assets_usd": (
+            round(float(latest["total_net_assets_usd"]), 2)
+            if latest["total_net_assets_usd"] is not None
+            else None
+        ),
+        "by_ticker": _ticker_breakdown(conn, asset, latest["flow_date"]),
+    }
+    if scope == "daily":
+        result["net_flow_usd_24h"] = result["net_flow_usd_1d"]
+    return result
+
+
+def build_etf_context(conn, *, now: datetime, scope: Scope, assets: list[str]) -> dict[str, Any]:
+    blocks: dict[str, Any] = {}
+    sources: set[str] = set()
+    for asset in assets:
+        block = build_etf_asset_context(conn, asset=asset, now=now, scope=scope)
+        blocks[asset.lower()] = block
+        if block.get("available") and block.get("source"):
+            sources.add(str(block["source"]))
+
+    if not any(block.get("available") for block in blocks.values()):
+        return {"available": False, "reason": "no_etf_data"}
+
+    return {
+        "available": True,
+        "assets": blocks,
+        "sources": sorted(sources),
+    }

alloccontext/rollup/fear_greed.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timezone
+from typing import Any
+
+
+def _row_to_context(row: sqlite3.Row, *, now: datetime) -> dict[str, Any]:
+    ts = int(row["ts"])
+    computed_at = datetime.fromtimestamp(ts, tz=timezone.utc)
+    age = max(0, int((now - computed_at).total_seconds()))
+    return {
+        "value": int(row["value"]),
+        "classification": str(row["classification"]),
+        "timestamp": ts,
+        "computed_at": computed_at.replace(microsecond=0).isoformat(),
+        "age_seconds": age,
+    }
+
+
+def build_fear_greed_context(
+    conn: sqlite3.Connection,
+    *,
+    now: datetime | None = None,
+    max_age_seconds: int = 86_400 * 2,
+) -> dict[str, Any] | None:
+    now = now or datetime.now(timezone.utc)
+    row = conn.execute(
+        """
+        SELECT ts, value, classification, fetched_at
+        FROM fear_greed ORDER BY CAST(ts AS INTEGER) DESC LIMIT 1
+        """
+    ).fetchone()
+    if row is None:
+        return None
+    ctx = _row_to_context(row, now=now)
+    if ctx["age_seconds"] > max_age_seconds:
+        ctx["stale"] = True
+    return ctx
+
+
+def fear_greed_at_or_before(
+    conn: sqlite3.Connection,
+    *,
+    at_ts: int,
+) -> dict[str, Any] | None:
+    row = conn.execute(
+        """
+        SELECT ts, value, classification, fetched_at
+        FROM fear_greed
+        WHERE CAST(ts AS INTEGER) <= ?
+        ORDER BY CAST(ts AS INTEGER) DESC
+        LIMIT 1
+        """,
+        (at_ts,),
+    ).fetchone()
+    if row is None:
+        return None
+    at = datetime.fromtimestamp(at_ts, tz=timezone.utc)
+    return _row_to_context(row, now=at)

alloccontext/rollup/macro.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from datetime import date, datetime, timedelta, timezone
+from typing import Any, Literal
+
+from alloccontext.rollup.etf import build_etf_context
+
+Scope = Literal["daily", "weekly"]
+
+
+def _row_to_event(row) -> dict[str, Any]:
+    return {
+        "event_id": row["event_id"],
+        "event_ts": row["event_ts"],
+        "country": row["country"],
+        "name": row["name"],
+        "impact": row["impact"],
+        "category": row["category"],
+        "actual": row["actual"],
+        "estimate": row["estimate"],
+        "previous": row["previous"],
+        "unit": row["unit"],
+        "source": row["source"],
+    }
+
+
+def _value_on_or_before(conn, *, series_id: str, target_date: date) -> tuple[str, float] | None:
+    row = conn.execute(
+        """
+        SELECT obs_date, value
+        FROM fred_observations
+        WHERE series_id = ? AND obs_date <= ? AND value IS NOT NULL
+        ORDER BY obs_date DESC
+        LIMIT 1
+        """,
+        (series_id, target_date.isoformat()),
+    ).fetchone()
+    if row is None:
+        return None
+    return str(row["obs_date"]), float(row["value"])
+
+
+def _latest_value(conn, *, series_id: str) -> tuple[str, float] | None:
+    row = conn.execute(
+        """
+        SELECT obs_date, value
+        FROM fred_observations
+        WHERE series_id = ? AND value IS NOT NULL
+        ORDER BY obs_date DESC
+        LIMIT 1
+        """,
+        (series_id,),
+    ).fetchone()
+    if row is None:
+        return None
+    return str(row["obs_date"]), float(row["value"])
+
+
+def _pct_change(current: float, prior: float) -> float | None:
+    if prior == 0:
+        return None
+    return round((current - prior) / prior * 100.0, 2)
+
+
+def _build_indicators(conn, config, *, now: datetime) -> dict[str, Any]:
+    specs = config.fred.series
+    if not specs:
+        return {"available": False, "reason": "no_series_configured"}
+
+    as_of_date = now.date()
+    indicators: dict[str, Any] = {}
+    for spec in specs:
+        latest = _latest_value(conn, series_id=spec.id)
+        if latest is None:
+            continue
+        obs_date, value = latest
+        entry: dict[str, Any] = {
+            "label": spec.label,
+            "category": spec.category,
+            "value": round(value, 4),
+            "obs_date": obs_date,
+        }
+        for days, key in ((7, "change_7d"), (30, "change_30d")):
+            prior = _value_on_or_before(
+                conn,
+                series_id=spec.id,
+                target_date=as_of_date - timedelta(days=days),
+            )
+            if prior is None:
+                continue
+            prior_date, prior_value = prior
+            delta = round(value - prior_value, 4)
+            entry[key] = delta
+            entry[f"{key}_from_date"] = prior_date
+            pct = _pct_change(value, prior_value)
+            if pct is not None:
+                entry[key.replace("change", "change_pct")] = pct
+        indicators[spec.id] = entry
+
+    if not indicators:
+        return {"available": False, "reason": "no_fred_data"}
+
+    return {"available": True, "indicators": indicators}
+
+
+def _build_events(conn, *, now: datetime, scope: Scope) -> dict[str, Any]:
+    past_hours = 24 if scope == "daily" else 24 * 7
+    future_days = 7
+    past_start = (now - timedelta(hours=past_hours)).isoformat()
+    future_end = (now + timedelta(days=future_days)).isoformat()
+    now_iso = now.isoformat()
+
+    rows = conn.execute(
+        """
+        SELECT event_id, event_ts, country, name, impact, category,
+               actual, estimate, previous, unit, source
+        FROM macro_events
+        WHERE event_ts >= ? AND event_ts <= ?
+        ORDER BY event_ts ASC
+        """,
+        (past_start, future_end),
+    ).fetchall()
+
+    if not rows:
+        return {"available": False, "reason": "no_events"}
+
+    past_key = "past_24h" if scope == "daily" else "past_7d"
+    past_events = [_row_to_event(row) for row in rows if row["event_ts"] < now_iso]
+    upcoming = [_row_to_event(row) for row in rows if row["event_ts"] >= now_iso]
+    sources = sorted({row["source"] for row in rows})
+
+    return {
+        "available": True,
+        "events": {
+            past_key: past_events,
+            "next_7d": upcoming,
+        },
+        "sources": sources,
+        "counts": {
+            past_key: len(past_events),
+            "next_7d": len(upcoming),
+        },
+    }
+
+
+def build_macro_context(
+    conn,
+    config,
+    *,
+    now: datetime,
+    scope: Scope,
+) -> dict[str, Any]:
+    if now.tzinfo is None:
+        now = now.replace(tzinfo=timezone.utc)
+
+    events_block = _build_events(conn, now=now, scope=scope)
+    etf_block = build_etf_context(
+        conn,
+        now=now,
+        scope=scope,
+        assets=list(config.etf.assets),
+    )
+    indicators_block = _build_indicators(conn, config, now=now)
+
+    if (
+        not events_block.get("available")
+        and not etf_block.get("available")
+        and not indicators_block.get("available")
+    ):
+        return {"available": False, "reason": "no_macro_data"}
+
+    sources = sorted(
+        set(events_block.get("sources") or [])
+        | set(etf_block.get("sources") or [])
+        | ({"fred"} if indicators_block.get("available") else set())
+    )
+    result: dict[str, Any] = {"available": True, "sources": sources}
+    if events_block.get("available"):
+        result["events"] = events_block["events"]
+        result["counts"] = events_block.get("counts", {})
+    if etf_block.get("available"):
+        result["etf"] = etf_block["assets"]
+    if indicators_block.get("available"):
+        result["indicators"] = indicators_block["indicators"]
+    return result