marketmyna 0.2.0__py3-none-any.whl

marketmyna/services/live_quotes.py

@@ -0,0 +1,295 @@
+"""Live prices for the rows on screen (Markets, Watchlist), shared by all users.
+
+The Markets listing is a whole-market snapshot refreshed every few hours.
+This module keeps a small cache of fresh quotes for just the symbols people
+are looking at:
+
+- Browsers ask every second (cheap: the answer comes from this cache).
+- The cache refreshes each market in the background, one batched upstream
+  call for every symbol anyone is watching, at most every REFRESH[market]
+  seconds. 1,000 users on the same page cost the data source the same as one.
+- Free sources: Yahoo for stocks / ETFs (can lag up to ~15 min for NSE),
+  Binance for crypto (real time). A licensed broker feed (Kite Connect,
+  Upstox, SmartAPI websockets) can replace `_fetch_*` for true tick data.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import threading
+import time
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Seconds between upstream refreshes per market (env LIVE_REFRESH_<MARKET>).
+REFRESH = {
+    "india": float(os.environ.get("LIVE_REFRESH_INDIA", 15)),
+    "us": float(os.environ.get("LIVE_REFRESH_US", 15)),
+    "china_a": float(os.environ.get("LIVE_REFRESH_CHINA_A", 30)),
+    "hong_kong": float(os.environ.get("LIVE_REFRESH_HONG_KONG", 30)),
+    "crypto": float(os.environ.get("LIVE_REFRESH_CRYPTO", 2)),
+}
+# With a broker feed (Angel One) Indian prices refresh every second.
+BROKER_REFRESH = float(os.environ.get("LIVE_REFRESH_BROKER", 1))
+WATCH_SECONDS = 60  # a symbol nobody asked about for a minute stops being fetched
+MAX_SYMBOLS = 100  # per request (one page of the table)
+SOURCE = {"crypto": "Crypto exchange, real time"}
+DEFAULT_SOURCE = "Market data feed, can lag up to 15 min"
+
+
+class _Market:
+    def __init__(self):
+        self.quotes: dict[str, dict] = {}  # symbol -> {price, change, change_percent, volume, time}
+        self.watched: dict[str, float] = {}  # symbol -> last asked (monotonic)
+        self.fetched_at = 0.0
+        self.error: Optional[str] = None
+        self.busy = False
+        self.lock = threading.Lock()
+
+
+_markets: dict[str, _Market] = {}
+_lock = threading.Lock()
+
+
+def _market(name: str) -> _Market:
+    with _lock:
+        return _markets.setdefault(name, _Market())
+
+
+def get(market: str, symbols: list[str], depth: bool = False) -> dict:
+    """Latest cached quotes for `symbols`; starts a background refresh when
+    the market's cache is older than its refresh interval. Never blocks on
+    the upstream source. The order book (broker feed only) is left out
+    unless `depth`, so the tables' per-second poll stays small."""
+    from ..trading.market_hours import is_open
+
+    m = _market(market)
+    now = time.monotonic()
+    symbols = [s.strip().upper() for s in symbols if s.strip()][:MAX_SYMBOLS]
+    open_now = is_open(market)
+    with m.lock:
+        for s in symbols:
+            m.watched[s] = now
+        stale = now - m.fetched_at >= refresh_seconds(market)
+        missing = any(s not in m.quotes for s in symbols)
+        start = (stale and (open_now or missing)) and not m.busy and market in REFRESH
+        if start:
+            m.busy = True
+        out = {s: m.quotes[s] if depth else {k: v for k, v in m.quotes[s].items() if k != "depth"}
+               for s in symbols if s in m.quotes}
+        age = None if not m.fetched_at else round(now - m.fetched_at, 1)
+        error = m.error
+    if start:
+        threading.Thread(target=_refresh, args=(market,), name=f"live-quotes-{market}", daemon=True).start()
+    return {
+        "market": market,
+        "open": open_now,
+        "quotes": out,
+        "age_seconds": age,
+        "refresh_seconds": refresh_seconds(market),
+        "source": source(market),
+        "error": error,
+        # Newest trade time among these quotes (epoch seconds). During "market
+        # hours" on a holiday this stays at the last session's close.
+        "last_trade": max((q.get("time") or 0 for q in out.values()), default=None) or None,
+    }
+
+
+def _refresh(market: str) -> None:
+    m = _market(market)
+    now = time.monotonic()
+    with m.lock:
+        m.watched = {s: t for s, t in m.watched.items() if now - t < WATCH_SECONDS}
+        symbols = list(m.watched)
+    try:
+        fresh = (_fetch_crypto(symbols) if market == "crypto" else _fetch_india(symbols) if market == "india"
+                 else _fetch_us(symbols) if market == "us" else _fetch_yahoo(symbols, market))
+        error = None
+    except Exception as exc:  # keep serving the last quotes
+        logger.warning("Live quotes for %s failed: %s", market, exc)
+        fresh, error = {}, "Live prices are temporarily unavailable; showing the last ones."
+    with m.lock:
+        m.quotes.update(fresh)
+        m.fetched_at = time.monotonic()
+        m.error = error
+        m.busy = False
+
+
+def _broker_config():
+    """App config when Angel One is set up (admin panel or env), else None."""
+    try:
+        from marketmyna.api.deps import get_config_dep
+
+        from .brokers import angel
+
+        config = get_config_dep()
+        return config if angel.configured(config) else None
+    except Exception:
+        return None
+
+
+_broker_failed_at = 0.0
+
+
+def _broker_live() -> bool:
+    # After a broker failure, a minute at the normal pace (Yahoo can't take 1 s polling).
+    return _broker_config() is not None and time.monotonic() - _broker_failed_at > 60
+
+
+def _finnhub_config():
+    try:
+        from marketmyna.api.deps import get_config_dep
+
+        from .brokers import finnhub
+
+        config = get_config_dep()
+        return config if finnhub.configured(config) else None
+    except Exception:
+        return None
+
+
+_yahoo_us_at = 0.0
+
+
+def _fetch_us(symbols: list[str]) -> dict[str, dict]:
+    """Finnhub's trade stream when a key is set (real time); Yahoo otherwise.
+    Symbols Finnhub has no price for yet are filled from Yahoo, at Yahoo's
+    normal 15 s pace."""
+    global _yahoo_us_at
+    config = _finnhub_config()
+    if config is None:
+        return _fetch_yahoo(symbols, "us")
+    from .brokers import finnhub
+
+    s = finnhub.stream(config)
+    s.want(symbols)
+    out = s.quotes(symbols)
+    rest = [x for x in symbols if x not in out]
+    if rest and time.monotonic() - _yahoo_us_at >= REFRESH["us"]:
+        _yahoo_us_at = time.monotonic()
+        try:
+            out.update(_fetch_yahoo(rest, "us"))
+        except Exception:
+            pass
+    return out
+
+
+def refresh_seconds(market: str) -> float:
+    if market == "us" and _finnhub_config() is not None:
+        return 1.0
+    if market == "india" and _broker_live():
+        # Every second for one batch of 50; slower when more symbols are watched,
+        # so the shared Angel account stays under its hourly call limit.
+        from .brokers.angel import BATCH, CALLS_PER_SECOND
+
+        batches = max(1, -(-len(_market("india").watched) // BATCH))
+        return max(BROKER_REFRESH, batches / CALLS_PER_SECOND)
+    return REFRESH.get(market, 30)
+
+
+def source(market: str) -> str:
+    if market == "us" and _finnhub_config() is not None:
+        return "Real-time feed"
+    if market == "india" and _broker_live():
+        return "Broker feed, live"
+    return SOURCE.get(market, DEFAULT_SOURCE)
+
+
+def _fetch_india(symbols: list[str]) -> dict[str, dict]:
+    """Angel One when configured (live); Yahoo otherwise or if it fails.
+    Symbols Angel can't price (e.g. BSE-only) are filled from Yahoo."""
+    global _broker_failed_at
+    config = _broker_config()
+    # During the minute after a failure (e.g. Angel's rate limit) stay on Yahoo.
+    if config is None or time.monotonic() - _broker_failed_at <= 60:
+        return _fetch_yahoo(symbols, "india")
+    from .brokers import angel
+
+    try:
+        out = angel.client(config).quotes(symbols)
+    except Exception as exc:
+        logger.warning("Angel One quotes failed, using Yahoo: %s", exc)
+        _broker_failed_at = time.monotonic()
+        return _fetch_yahoo(symbols, "india")
+    rest = [s for s in symbols if s not in out]
+    if rest:
+        try:
+            out.update(_fetch_yahoo(rest, "india"))
+        except Exception:
+            pass
+    return out
+
+
+def _fetch_crypto(symbols: list[str]) -> dict[str, dict]:
+    """Binance 24h tickers for BASE-USD symbols (USDT pairs), one request."""
+    import json
+
+    import requests
+
+    pairs = {f"{s.split('-')[0]}USDT": s for s in symbols if s}
+    if not pairs:
+        return {}
+    r = requests.get("https://api.binance.com/api/v3/ticker/24hr",
+                     params={"symbols": json.dumps(list(pairs), separators=(",", ":"))}, timeout=10)
+    r.raise_for_status()
+    stamp = time.time()
+    out = {}
+    for t in r.json():
+        sym = pairs.get(t.get("symbol"))
+        price = _num(t.get("lastPrice"))
+        if sym and price:
+            out[sym] = {"price": price, "change": _num(t.get("priceChange")),
+                        "change_percent": _num(t.get("priceChangePercent")),
+                        "volume": _num(t.get("quoteVolume")), "time": stamp}
+    return out
+
+
+def _fetch_yahoo(symbols: list[str], market: str) -> dict[str, dict]:
+    """One batched 1-minute download for every watched symbol: last trade,
+    change against the previous session's close, and today's volume."""
+    import pandas as pd
+    import yfinance as yf
+
+    from ..utils.yf_lock import YF_DOWNLOAD_LOCK
+    from .analysis_run import yahoo_symbol
+
+    if not symbols:
+        return {}
+    tickers = {yahoo_symbol(s, market): s for s in symbols}
+    with YF_DOWNLOAD_LOCK:
+        df = yf.download(list(tickers), period="5d", interval="1m", group_by="ticker", progress=False,
+                         threads=True, auto_adjust=False, prepost=False)
+    out = {}
+    for yt, sym in tickers.items():
+        try:
+            # group_by="ticker" nests columns under the ticker even for one
+            # symbol in current yfinance; older releases returned them flat.
+            frame = df[yt] if len(tickers) > 1 or isinstance(df.columns, pd.MultiIndex) else df
+            frame = frame.dropna(subset=["Close"])
+        except (KeyError, TypeError):
+            continue
+        if frame.empty:
+            continue
+        last_day = frame.index[-1].date()
+        today = frame[frame.index.date == last_day]
+        before = frame[frame.index.date < last_day]
+        price = float(today["Close"].iloc[-1])
+        prev = float(before["Close"].iloc[-1]) if not before.empty else None
+        change = price - prev if prev else None
+        out[sym] = {
+            "price": round(price, 4),
+            "change": round(change, 4) if change is not None else None,
+            "change_percent": round(change / prev * 100, 2) if prev else None,
+            "volume": float(today["Volume"].sum()) if "Volume" in today else None,
+            "time": frame.index[-1].timestamp(),
+        }
+    return out
+
+
+def _num(value) -> Optional[float]:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None

marketmyna/services/macro.py

@@ -0,0 +1,182 @@
+"""Macro dashboard: key US / India / global series from FRED's public CSV
+export (no API key), with latest value, 1-month and 1-year change and a
+monthly sparkline. Covers the core of OpenBB's economy / fixedincome
+endpoints that matter to an equity investor.
+"""
+
+from __future__ import annotations
+
+import io
+import logging
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from datetime import date, timedelta
+from typing import Callable, Optional
+
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+FRED_CSV = "https://fred.stlouisfed.org/graph/fredgraph.csv?id={id}&cosd={start}"
+CACHE_SECONDS = 6 * 3600
+YEARS = 5
+
+# id, label, group, unit, transform (level | yoy), note
+SERIES = [
+    ("CPIAUCSL", "US inflation (CPI)", "us", "%", "yoy", "Consumer prices vs a year ago"),
+    ("FEDFUNDS", "Fed funds rate", "us", "%", "level", "US policy rate"),
+    ("DGS10", "US 10-year yield", "us", "%", "level", "Long-term borrowing cost; higher weighs on stock valuations"),
+    ("DGS2", "US 2-year yield", "us", "%", "level", "Tracks where the Fed is expected to go"),
+    ("T10Y2Y", "US yield curve (10y - 2y)", "us", "pts", "level", "Below 0 (inverted) has preceded most US recessions"),
+    ("UNRATE", "US unemployment", "us", "%", "level", "Share of the labour force out of work"),
+    ("INDIRLTLT01STM", "India 10-year yield", "india", "%", "level", "Government bond yield"),
+    ("IRSTCI01INM156N", "India call money rate", "india", "%", "level", "Overnight interbank rate, tracks RBI policy"),
+    ("DEXINUS", "USD / INR", "india", "₹", "level", "Rupees per dollar; higher = weaker rupee"),
+    ("DCOILBRENTEU", "Brent crude", "global", "$", "level", "Oil price; a big cost driver for India"),
+]
+
+Fetch = Callable[[str, date], pd.Series]
+
+_cache: dict[str, tuple[float, dict]] = {}
+_lock = threading.Lock()
+
+
+def _fred(series_id: str, start: date) -> pd.Series:
+    import requests
+
+    # FRED stalls requests with an unknown custom User-Agent; the library default works.
+    resp = requests.get(FRED_CSV.format(id=series_id, start=start.isoformat()), timeout=20)
+    resp.raise_for_status()
+    df = pd.read_csv(io.StringIO(resp.text))
+    s = pd.to_numeric(df.iloc[:, 1], errors="coerce")
+    s.index = pd.to_datetime(df.iloc[:, 0])
+    return s.dropna()
+
+
+def _asof(s: pd.Series, when: pd.Timestamp) -> Optional[float]:
+    past = s[s.index <= when]
+    return float(past.iloc[-1]) if len(past) else None
+
+
+def _fetch_one(fetch: Fetch, spec: tuple, start: date) -> tuple:
+    """(spec, series) for one FRED series; series is None when the fetch fails."""
+    try:
+        return spec, fetch(spec[0], start)
+    except Exception as exc:
+        logger.warning("FRED %s failed: %s", spec[0], exc)
+        return spec, None
+
+
+def shape(series_id: str, label: str, group: str, unit: str, transform: str, note: str, raw: pd.Series) -> Optional[dict]:
+    s = raw.sort_index()
+    if transform == "yoy":
+        monthly = s.resample("MS").last().dropna()
+        s = (monthly / monthly.shift(12) - 1).dropna() * 100
+    if s.empty:
+        return None
+    last_day = s.index[-1]
+    value = float(s.iloc[-1])
+    m1, y1 = _asof(s, last_day - pd.DateOffset(months=1)), _asof(s, last_day - pd.DateOffset(years=1))
+    spark = s.resample("MS").last().dropna().tail(36)
+    return {"id": series_id, "label": label, "group": group, "unit": unit, "note": note,
+            "value": value, "date": str(last_day.date()),
+            "change_1m": value - m1 if m1 is not None else None,
+            "change_1y": value - y1 if y1 is not None else None,
+            "spark": [{"date": str(i.date()), "value": float(v)} for i, v in spark.items()]}
+
+
+def build(fetch: Fetch = _fred, use_cache: bool = True) -> dict:
+    if use_cache:
+        with _lock:
+            hit = _cache.get("all")
+            if hit and time.time() - hit[0] < CACHE_SECONDS:
+                return hit[1]
+    start = date.today() - timedelta(days=365 * YEARS + 400)  # extra year for YoY
+
+    with ThreadPoolExecutor(max_workers=6) as pool:
+        results = list(pool.map(lambda spec: _fetch_one(fetch, spec, start), SERIES))
+    series, failed = [], []
+    for spec, raw in results:
+        item = shape(*spec, raw) if raw is not None and len(raw) else None
+        (series.append(item) if item else failed.append(spec[1]))
+    curve = next((s for s in series if s["id"] == "T10Y2Y"), None)
+    out = {"series": series, "failed": failed,
+           "signals": {"us_curve_inverted": curve["value"] < 0 if curve else None},
+           "source": "Official central bank and government statistics"}
+    if use_cache and series:
+        with _lock:
+            _cache["all"] = (time.time(), out)
+    return out
+
+
+def context_lines(data: Optional[dict] = None) -> list[str]:
+    """Short text lines for LLM prompts (agent context)."""
+    data = data or build()
+    lines = []
+    for s in data["series"]:
+        chg = f", {s['change_1y']:+.2f} over 1y" if s.get("change_1y") is not None else ""
+        lines.append(f"{s['label']}: {s['value']:.2f}{'' if s['unit'] in ('₹', '$') else s['unit']} ({s['date']}{chg})")
+    return lines
+
+
+def cached_context() -> list[str]:
+    """Macro lines for prompts without ever blocking: uses the cache, and if it
+    is cold, warms it on a background thread and returns nothing this time."""
+    with _lock:
+        hit = _cache.get("all")
+    if hit and time.time() - hit[0] < CACHE_SECONDS:
+        return context_lines(hit[1]) + _india_cached()
+    threading.Thread(target=build, name="macro-warm", daemon=True).start()
+    return []
+
+
+def _india_cached() -> list[str]:
+    """RBI / IBJA lines if that cache is warm; never fetches."""
+    from . import india_rates
+
+    with india_rates._lock:
+        hit = india_rates._cache.get("all")
+    if hit and time.time() - hit[0] < india_rates.CACHE_SECONDS:
+        return india_rates.context_lines(hit[1])
+    return []
+
+
+# US Treasury constant-maturity yields, short to long (FRED, daily).
+CURVE = [("DGS1MO", "1M", 1 / 12), ("DGS3MO", "3M", 0.25), ("DGS6MO", "6M", 0.5), ("DGS1", "1Y", 1),
+         ("DGS2", "2Y", 2), ("DGS3", "3Y", 3), ("DGS5", "5Y", 5), ("DGS7", "7Y", 7),
+         ("DGS10", "10Y", 10), ("DGS20", "20Y", 20), ("DGS30", "30Y", 30)]
+
+
+def yield_curve(fetch: Fetch = _fred, use_cache: bool = True) -> dict:
+    """US Treasury curve today vs 1 month and 1 year ago, plus its shape."""
+    if use_cache:
+        with _lock:
+            hit = _cache.get("curve")
+            if hit and time.time() - hit[0] < CACHE_SECONDS:
+                return hit[1]
+    start = date.today() - timedelta(days=400)
+
+    with ThreadPoolExecutor(max_workers=6) as pool:
+        got = [(spec, s) for spec, s in pool.map(lambda spec: _fetch_one(fetch, spec, start), CURVE) if s is not None and len(s)]
+    if not got:
+        return {"points": [], "as_of": None}
+    as_of = min(s.index[-1] for _, s in got)  # a date every tenor has printed
+    points = []
+    for (sid, label, years), s in got:
+        points.append({"id": sid, "tenor": label, "years": years,
+                       "now": _asof(s, as_of),
+                       "month_ago": _asof(s, as_of - pd.Timedelta(days=30)),
+                       "year_ago": _asof(s, as_of - pd.Timedelta(days=365))})
+    by = {p["tenor"]: p["now"] for p in points}
+    shape_ = None
+    if by.get("3M") is not None and by.get("10Y") is not None:
+        spread = by["10Y"] - by["3M"]
+        shape_ = {"spread_10y_3m": spread,
+                  "label": "inverted" if spread < 0 else "flat" if spread < 0.5 else "normal"}
+    out = {"points": points, "as_of": str(as_of.date()), "shape": shape_,
+           "source": "Official US Treasury constant-maturity yields"}
+    if use_cache:
+        with _lock:
+            _cache["curve"] = (time.time(), out)
+    return out