alloc-context 0.1.0__py3-none-any.whl

alloccontext/ingest/kraken_client.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import time
+import urllib.parse
+from typing import Any
+
+import requests
+
+from alloccontext.ingest.exchange_http import should_retry_exchange_attempt
+
+KRAKEN_API = "https://api.kraken.com"
+
+ASSET_TO_SYMBOL = {
+    "XXBT": "BTC",
+    "XBT": "BTC",
+    "XETH": "ETH",
+    "ETH": "ETH",
+    "ZUSD": "USD",
+    "USD": "USD",
+    "USDT": "USD",
+    "USDC": "USD",
+    "DAI": "USD",
+    "PYUSD": "USD",
+    "USDE": "USD",
+    "TUSD": "USD",
+    "USDD": "USD",
+    "GUSD": "USD",
+}
+
+PAIR_TO_SYMBOL = {
+    "XBTUSD": "BTC",
+    "XXBTZUSD": "BTC",
+    "ETHUSD": "ETH",
+    "XETHZUSD": "ETH",
+}
+
+
+def pair_to_symbol(pair: str) -> str:
+    return PAIR_TO_SYMBOL.get(pair.upper(), pair.replace("USD", "").replace("XBT", "BTC"))
+
+
+def _kraken_asset_base(asset: str) -> str:
+    return asset.split(".", 1)[0]
+
+
+def normalize_kraken_balances(raw: dict[str, Any]) -> dict[str, float]:
+    balances: dict[str, float] = {"BTC": 0.0, "ETH": 0.0, "USD": 0.0}
+    for asset, amount in raw.items():
+        symbol = ASSET_TO_SYMBOL.get(_kraken_asset_base(asset))
+        if symbol:
+            balances[symbol] = balances.get(symbol, 0.0) + float(amount)
+    return balances
+
+
+def cash_breakdown_from_raw(raw: dict[str, Any]) -> dict[str, float]:
+    breakdown: dict[str, float] = {}
+    for asset, amount in raw.items():
+        base = _kraken_asset_base(asset)
+        if ASSET_TO_SYMBOL.get(base) != "USD":
+            continue
+        value = float(amount)
+        if value <= 0:
+            continue
+        breakdown[base] = breakdown.get(base, 0.0) + value
+    return breakdown
+
+
+class KrakenError(Exception):
+    pass
+
+
+class KrakenClient:
+    """Read-only Kraken REST client (balances, ticker, OHLC)."""
+
+    def __init__(
+        self,
+        api_key: str = "",
+        api_secret: str = "",
+        *,
+        retry_backoff: float = 2.0,
+        max_retries: int = 3,
+        session: requests.Session | None = None,
+    ) -> None:
+        self.api_key = api_key.strip()
+        self.api_secret = api_secret.strip()
+        self.retry_backoff = retry_backoff
+        self.max_retries = max_retries
+        self.session = session or requests.Session()
+
+    def get_ticker(self, pair: str) -> dict[str, float]:
+        data = self._public("Ticker", {"pair": pair})
+        key = next(iter(data))
+        ticker = data[key]
+        return {
+            "last": float(ticker["c"][0]),
+            "bid": float(ticker["b"][0]),
+            "ask": float(ticker["a"][0]),
+        }
+
+    def get_ohlc(self, pair: str, interval: int = 1440) -> list[dict[str, float]]:
+        data = self._public("OHLC", {"pair": pair, "interval": interval})
+        key = next(k for k in data if k != "last")
+        candles: list[dict[str, float]] = []
+        for row in data[key]:
+            candles.append(
+                {
+                    "time": float(row[0]),
+                    "open": float(row[1]),
+                    "high": float(row[2]),
+                    "low": float(row[3]),
+                    "close": float(row[4]),
+                }
+            )
+        return candles
+
+    def get_balances_with_breakdown(
+        self,
+    ) -> tuple[dict[str, float], dict[str, float]]:
+        if not self.api_key or not self.api_secret:
+            raise KrakenError("KRAKEN_API_KEY and KRAKEN_API_SECRET required for balances")
+        raw = self._private("Balance")
+        return normalize_kraken_balances(raw), cash_breakdown_from_raw(raw)
+
+    def _public(self, path: str, params: dict[str, Any]) -> dict[str, Any]:
+        return self._request("GET", f"/0/public/{path}", params=params)
+
+    def _private(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._request("POST", f"/0/private/{path}", data=params or {})
+
+    @staticmethod
+    def _sign(private_path: str, payload: dict[str, Any], api_secret: str) -> str:
+        post_data = urllib.parse.urlencode(payload)
+        nonce = str(payload["nonce"])
+        encoded = (nonce + post_data).encode()
+        message = private_path.encode() + hashlib.sha256(encoded).digest()
+        secret = base64.b64decode(api_secret)
+        digest = hmac.new(secret, message, hashlib.sha512).digest()
+        return base64.b64encode(digest).decode()
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        url = KRAKEN_API + path
+        last_error: Exception | None = None
+        for attempt in range(self.max_retries):
+            try:
+                headers: dict[str, str] = {}
+                if path.startswith("/0/private"):
+                    nonce = str(int(time.time() * 1000))
+                    payload = {"nonce": nonce, **(data or {})}
+                    headers = {
+                        "API-Key": self.api_key,
+                        "API-Sign": self._sign(path, payload, self.api_secret),
+                    }
+                    resp = self.session.post(url, data=payload, headers=headers, timeout=30)
+                else:
+                    resp = self.session.get(url, params=params, timeout=30)
+                resp.raise_for_status()
+                body = resp.json()
+                if body.get("error"):
+                    raise KrakenError("; ".join(body["error"]))
+                return body["result"]
+            except Exception as exc:  # noqa: BLE001
+                last_error = exc
+                if attempt + 1 < self.max_retries and should_retry_exchange_attempt(exc):
+                    time.sleep(self.retry_backoff * (attempt + 1))
+                    continue
+                break
+        raise KrakenError(str(last_error)) from last_error

alloccontext/ingest/kraken_portfolio.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+from alloccontext.ingest.kraken_client import KrakenClient, pair_to_symbol
+
+
+@dataclass
+class PortfolioSnapshot:
+    ts: str
+    nav_usd: float
+    cash_usd: float
+    btc_usd: float
+    eth_usd: float
+    btc_pct: float
+    eth_pct: float
+    cash_pct: float
+    prices: dict[str, float]
+    cash_breakdown: dict[str, float] = field(default_factory=dict)
+
+
+def load_kraken_credentials() -> tuple[str, str] | None:
+    api_key = os.environ.get("KRAKEN_API_KEY", "").strip()
+    api_secret = os.environ.get("KRAKEN_API_SECRET", "").strip()
+    if api_key and api_secret:
+        return api_key, api_secret
+    return None
+
+
+def build_kraken_client(spot) -> KrakenClient:
+    creds = load_kraken_credentials()
+    return KrakenClient(
+        api_key=creds[0] if creds else "",
+        api_secret=creds[1] if creds else "",
+        retry_backoff=spot.retry_backoff_seconds,
+        max_retries=spot.max_retries,
+    )
+
+
+def portfolio_from_balances(
+    balances: dict[str, float],
+    prices: dict[str, float],
+    *,
+    cash_breakdown: dict[str, float] | None = None,
+) -> PortfolioSnapshot:
+    btc_usd = balances.get("BTC", 0.0) * prices.get("BTC", 0.0)
+    eth_usd = balances.get("ETH", 0.0) * prices.get("ETH", 0.0)
+    cash_usd = balances.get("USD", 0.0)
+    total = btc_usd + eth_usd + cash_usd
+    if total <= 0:
+        return PortfolioSnapshot(
+            ts="",
+            nav_usd=0.0,
+            cash_usd=0.0,
+            btc_usd=0.0,
+            eth_usd=0.0,
+            btc_pct=0.0,
+            eth_pct=0.0,
+            cash_pct=0.0,
+            prices=dict(prices),
+            cash_breakdown=dict(cash_breakdown or {}),
+        )
+    return PortfolioSnapshot(
+        ts="",
+        nav_usd=total,
+        cash_usd=cash_usd,
+        btc_usd=btc_usd,
+        eth_usd=eth_usd,
+        btc_pct=btc_usd / total,
+        eth_pct=eth_usd / total,
+        cash_pct=cash_usd / total,
+        prices=dict(prices),
+        cash_breakdown=dict(cash_breakdown or {}),
+    )
+
+
+def fetch_portfolio_snapshot(client: KrakenClient, spot) -> PortfolioSnapshot:
+    prices: dict[str, float] = {}
+    for pair in spot.pairs:
+        symbol = pair_to_symbol(pair)
+        prices[symbol] = client.get_ticker(pair)["last"]
+    balances, cash_breakdown = client.get_balances_with_breakdown()
+    snap = portfolio_from_balances(balances, prices, cash_breakdown=cash_breakdown)
+    snap.ts = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+    return snap
+
+
+def upsert_portfolio_snapshot(conn: sqlite3.Connection, snap: PortfolioSnapshot) -> None:
+    allocation = {
+        "BTC": snap.btc_pct,
+        "ETH": snap.eth_pct,
+        "CASH": snap.cash_pct,
+        "btc_usd": snap.btc_usd,
+        "eth_usd": snap.eth_usd,
+        "prices": snap.prices,
+        "cash_breakdown": snap.cash_breakdown,
+    }
+    raw = {**asdict(snap), "allocation": allocation}
+    conn.execute(
+        """
+        INSERT INTO portfolio_snapshots(ts, nav_usd, cash_usd, allocation_json, raw_json)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(ts) DO UPDATE SET
+          nav_usd=excluded.nav_usd,
+          cash_usd=excluded.cash_usd,
+          allocation_json=excluded.allocation_json,
+          raw_json=excluded.raw_json
+        """,
+        (
+            snap.ts,
+            snap.nav_usd,
+            snap.cash_usd,
+            json.dumps(allocation, sort_keys=True),
+            json.dumps(raw, sort_keys=True),
+        ),
+    )
+
+
+def upsert_market_bars(
+    conn: sqlite3.Connection,
+    *,
+    pair: str,
+    interval_minutes: int,
+    bars: list[dict[str, float]],
+) -> int:
+    count = 0
+    for bar in bars:
+        conn.execute(
+            """
+            INSERT INTO market_bars(
+              pair, interval_minutes, bar_ts, open, high, low, close
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(pair, interval_minutes, bar_ts) DO UPDATE SET
+              open=excluded.open,
+              high=excluded.high,
+              low=excluded.low,
+              close=excluded.close
+            """,
+            (
+                pair,
+                interval_minutes,
+                int(bar["time"]),
+                float(bar["open"]),
+                float(bar["high"]),
+                float(bar["low"]),
+                float(bar["close"]),
+            ),
+        )
+        count += 1
+    return count
+
+
+def refresh_kraken(conn: sqlite3.Connection, config) -> dict[str, Any]:
+    from alloccontext.ingest.exchange.registry import refresh_exchange
+
+    return refresh_exchange(conn, config, "kraken")

alloccontext/ingest/macro_calendar.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import urllib.error
+import urllib.request
+from datetime import date, datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from alloccontext.ingest.macro_normalize import (
+    calendar_row_date_time,
+    impact_meets_minimum,
+    normalize_impact,
+    normalized_event,
+    parse_event_ts,
+)
+
+FINNHUB_URL = "https://finnhub.io/api/v1/calendar/economic"
+FMP_URL = "https://financialmodelingprep.com/stable/economic-calendar"
+
+
+def load_static_events(path: Path, *, countries: set[str], min_impact: str) -> list[dict[str, Any]]:
+    if not path.exists():
+        return []
+    raw = yaml.safe_load(path.read_text()) or {}
+    tz_name = str(raw.get("timezone") or "America/New_York")
+    rows: list[dict[str, Any]] = []
+    for item in raw.get("events") or []:
+        if not isinstance(item, dict):
+            continue
+        country = str(item.get("country") or "US").upper()
+        if countries and country not in countries:
+            continue
+        impact = normalize_impact(str(item.get("impact") or "high"))
+        if not impact_meets_minimum(impact, min_impact):
+            continue
+        event_date = str(item.get("date") or "").strip()
+        if not event_date:
+            continue
+        event_ts = parse_event_ts(
+            date=event_date,
+            time=str(item.get("time") or "00:00"),
+            tz_name=tz_name,
+        )
+        rows.append(
+            normalized_event(
+                source="static",
+                country=country,
+                name=str(item.get("name") or "Macro event"),
+                event_ts=event_ts,
+                impact=impact,
+                category=str(item.get("category") or "macro"),
+                raw=dict(item),
+            )
+        )
+    return rows
+
+
+def fetch_finnhub_events(
+    *,
+    start: date,
+    end: date,
+    api_key: str,
+    countries: set[str],
+    min_impact: str,
+    timeout: float = 20.0,
+) -> list[dict[str, Any]]:
+    url = (
+        f"{FINNHUB_URL}?from={start.isoformat()}&to={end.isoformat()}"
+        f"&token={api_key}"
+    )
+    req = urllib.request.Request(url, headers={"User-Agent": "alloc-context/0.1"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            payload = json.loads(resp.read().decode())
+    except urllib.error.HTTPError as exc:
+        from alloccontext.ingest.http_errors import http_error_message
+
+        raise ValueError(
+            http_error_message(exc, context="finnhub economic calendar")
+        ) from exc
+    calendar = payload.get("economicCalendar") if isinstance(payload, dict) else payload
+    if not isinstance(calendar, list):
+        raise ValueError("invalid finnhub economic calendar payload")
+
+    rows: list[dict[str, Any]] = []
+    for item in calendar:
+        if not isinstance(item, dict):
+            continue
+        country = str(item.get("country") or "").upper()
+        if countries and country not in countries:
+            continue
+        impact = normalize_impact(str(item.get("impact") or "medium"))
+        if not impact_meets_minimum(impact, min_impact):
+            continue
+        when = calendar_row_date_time(item)
+        if when is None:
+            continue
+        event_date, event_time = when
+        event_ts = parse_event_ts(
+            date=event_date,
+            time=event_time,
+            tz_name="America/New_York",
+        )
+        rows.append(
+            normalized_event(
+                source="finnhub",
+                country=country or "US",
+                name=str(item.get("event") or "Economic release"),
+                event_ts=event_ts,
+                impact=impact,
+                category="economic",
+                actual=item.get("actual"),
+                estimate=item.get("estimate"),
+                previous=item.get("prev"),
+                unit=item.get("unit"),
+                raw=item,
+            )
+        )
+    return rows
+
+
+def fetch_fmp_events(
+    *,
+    start: date,
+    end: date,
+    api_key: str,
+    countries: set[str],
+    min_impact: str,
+    timeout: float = 20.0,
+) -> list[dict[str, Any]]:
+    url = (
+        f"{FMP_URL}?from={start.isoformat()}&to={end.isoformat()}"
+        f"&apikey={api_key}"
+    )
+    req = urllib.request.Request(url, headers={"User-Agent": "alloc-context/0.1"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            payload = json.loads(resp.read().decode())
+    except urllib.error.HTTPError as exc:
+        from alloccontext.ingest.http_errors import http_error_message
+
+        raise ValueError(http_error_message(exc, context="fmp economic calendar")) from exc
+    if not isinstance(payload, list):
+        raise ValueError("invalid fmp economic calendar payload")
+
+    rows: list[dict[str, Any]] = []
+    for item in payload:
+        if not isinstance(item, dict):
+            continue
+        country = str(item.get("country") or item.get("currency") or "US").upper()
+        if len(country) == 3 and country in {"USD", "EUR", "GBP"}:
+            country = {"USD": "US", "EUR": "EU", "GBP": "UK"}.get(country, country)
+        if countries and country not in countries:
+            continue
+        impact = normalize_impact(str(item.get("impact") or item.get("importance") or "medium"))
+        if not impact_meets_minimum(impact, min_impact):
+            continue
+        event_date = str(item.get("date") or "").strip()[:10]
+        if not event_date:
+            continue
+        event_ts = parse_event_ts(
+            date=event_date,
+            time=str(item.get("time") or item.get("releaseTime") or "00:00:00"),
+            tz_name="America/New_York",
+        )
+        rows.append(
+            normalized_event(
+                source="fmp",
+                country=country or "US",
+                name=str(item.get("event") or item.get("name") or "Economic release"),
+                event_ts=event_ts,
+                impact=impact,
+                category="economic",
+                actual=item.get("actual"),
+                estimate=item.get("estimate") or item.get("forecast"),
+                previous=item.get("previous") or item.get("prior"),
+                unit=item.get("unit"),
+                raw=item,
+            )
+        )
+    return rows
+
+
+def merge_events(*feeds: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Prefer earlier feeds on duplicate day+name (static wins over API)."""
+    merged: dict[str, dict[str, Any]] = {}
+    for feed in feeds:
+        for event in feed:
+            key = f"{event['event_ts'][:10]}:{event['name'].lower()}"
+            if key not in merged:
+                merged[key] = event
+    return sorted(merged.values(), key=lambda row: row["event_ts"])
+
+
+def upsert_macro_events(conn: sqlite3.Connection, events: list[dict[str, Any]]) -> int:
+    fetched_at = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+    count = 0
+    for event in events:
+        conn.execute(
+            """
+            INSERT INTO macro_events(
+              event_id, event_ts, country, name, impact, category,
+              actual, estimate, previous, unit, source, raw_json, fetched_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(event_id) DO UPDATE SET
+              event_ts = excluded.event_ts,
+              country = excluded.country,
+              name = excluded.name,
+              impact = excluded.impact,
+              category = excluded.category,
+              actual = excluded.actual,
+              estimate = excluded.estimate,
+              previous = excluded.previous,
+              unit = excluded.unit,
+              source = excluded.source,
+              raw_json = excluded.raw_json,
+              fetched_at = excluded.fetched_at
+            """,
+            (
+                event["event_id"],
+                event["event_ts"],
+                event["country"],
+                event["name"],
+                event["impact"],
+                event.get("category"),
+                _json_scalar(event.get("actual")),
+                _json_scalar(event.get("estimate")),
+                _json_scalar(event.get("previous")),
+                event.get("unit"),
+                event["source"],
+                json.dumps(event.get("raw") or {}),
+                fetched_at,
+            ),
+        )
+        count += 1
+    return count
+
+
+def _json_scalar(value: Any) -> str | None:
+    if value is None:
+        return None
+    return str(value)
+
+
+def refresh_macro_calendar(conn: sqlite3.Connection, config) -> dict[str, Any]:
+    macro = config.macro
+    countries = {c.upper() for c in macro.countries}
+    today = datetime.now(timezone.utc).date()
+    start = today - timedelta(days=macro.fetch_past_days)
+    end = today + timedelta(days=macro.fetch_future_days)
+
+    feeds: list[list[dict[str, Any]]] = []
+    feed_errors: dict[str, str] = {}
+
+    static_path = Path(macro.static_calendar)
+    static_rows = load_static_events(
+        static_path, countries=countries, min_impact=macro.min_impact
+    )
+    feeds.append(static_rows)
+
+    finnhub_key = os.environ.get("FINNHUB_API_KEY")
+    if macro.finnhub_enabled and finnhub_key:
+        try:
+            feeds.append(
+                fetch_finnhub_events(
+                    start=start,
+                    end=end,
+                    api_key=finnhub_key,
+                    countries=countries,
+                    min_impact=macro.min_impact,
+                    timeout=macro.timeout_seconds,
+                )
+            )
+        except (urllib.error.URLError, TimeoutError, ValueError, json.JSONDecodeError) as exc:
+            feed_errors["finnhub"] = str(exc)
+
+    fmp_key = os.environ.get("FMP_API_KEY")
+    if macro.fmp_enabled and fmp_key:
+        try:
+            feeds.append(
+                fetch_fmp_events(
+                    start=start,
+                    end=end,
+                    api_key=fmp_key,
+                    countries=countries,
+                    min_impact=macro.min_impact,
+                    timeout=macro.timeout_seconds,
+                )
+            )
+        except (urllib.error.URLError, TimeoutError, ValueError, json.JSONDecodeError) as exc:
+            feed_errors["fmp"] = str(exc)
+
+    merged = merge_events(*feeds)
+    upserted = upsert_macro_events(conn, merged)
+    conn.commit()
+
+    ok = upserted > 0 or bool(static_rows)
+    return {
+        "ok": ok,
+        "rows": upserted,
+        "static_rows": len(static_rows),
+        "feed_errors": feed_errors,
+        "sources": sorted({row["source"] for row in merged}),
+    }