marketmyna 0.2.0__py3-none-any.whl

marketmyna/services/cot.py

@@ -0,0 +1,148 @@
+"""Commitments of Traders: how hedge funds and producers are positioned in the
+main US commodity futures, from the CFTC's disaggregated futures-only report
+(publicreporting.cftc.gov, no key).
+
+Positions are as of each Tuesday and published the following Friday. For each
+market this gives managed money (hedge funds, CTAs) net long contracts, the
+weekly change, net as a share of open interest, producers' / merchants' net
+(commercial hedgers) and a 3-year position index: where this week's managed
+money net sits between its 3-year low (0) and high (100). The reading is a
+description of positioning, not a forecast. Brent is not covered: it trades on
+ICE Futures Europe, outside the CFTC's report.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from datetime import date, timedelta
+from typing import Callable, Optional
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+API = "https://publicreporting.cftc.gov/resource/72hh-3qpy.json"
+CACHE_SECONDS = 6 * 3600
+YEARS = 3
+
+# Yahoo ticker on the Commodities card, label, CFTC contract market code
+MARKETS = [
+    ("GC=F", "Gold", "088691"),
+    ("SI=F", "Silver", "084691"),
+    ("HG=F", "Copper", "085692"),
+    ("CL=F", "WTI crude", "067651"),
+    ("NG=F", "Natural gas", "023651"),
+    ("ZW=F", "Wheat", "001602"),
+    ("ZC=F", "Corn", "002602"),
+]
+
+Fetch = Callable[[list[str], date], list[dict]]
+
+_cache: dict[str, tuple[float, dict]] = {}
+_lock = threading.Lock()
+
+
+def _fetch(codes: list[str], since: date) -> list[dict]:
+    where = (f"cftc_contract_market_code in({','.join(repr(c) for c in codes)}) "
+             f"AND report_date_as_yyyy_mm_dd >= '{since.isoformat()}T00:00:00'")
+    params = {
+        "$select": ("cftc_contract_market_code,report_date_as_yyyy_mm_dd,open_interest_all,"
+                    "m_money_positions_long_all,m_money_positions_short_all,"
+                    "prod_merc_positions_long,prod_merc_positions_short"),
+        "$where": where,
+        "$order": "report_date_as_yyyy_mm_dd",
+        "$limit": 5000,
+    }
+    r = requests.get(API, params=params, timeout=30)
+    r.raise_for_status()
+    return r.json()
+
+
+def _int(row: dict, key: str) -> int:
+    return int(float(row.get(key) or 0))
+
+
+def reading(index: Optional[float]) -> str:
+    if index is None:
+        return ""
+    if index >= 90:
+        return "Funds near their most long in 3 years"
+    if index <= 10:
+        return "Funds near their most short in 3 years"
+    if index >= 70:
+        return "Funds longer than usual"
+    if index <= 30:
+        return "Funds shorter than usual"
+    return "Fund positioning mid-range"
+
+
+def summarise(rows: list[dict]) -> Optional[dict]:
+    """One market's weekly rows (oldest first) -> latest positioning."""
+    weeks = []
+    for r in rows:
+        weeks.append({
+            "date": (r.get("report_date_as_yyyy_mm_dd") or "")[:10],
+            "oi": _int(r, "open_interest_all"),
+            "mm_net": _int(r, "m_money_positions_long_all") - _int(r, "m_money_positions_short_all"),
+            "mm_long": _int(r, "m_money_positions_long_all"),
+            "mm_short": _int(r, "m_money_positions_short_all"),
+            "prod_net": _int(r, "prod_merc_positions_long") - _int(r, "prod_merc_positions_short"),
+        })
+    weeks = sorted({w["date"]: w for w in weeks if w["date"]}.values(), key=lambda w: w["date"])
+    if not weeks:
+        return None
+    last = weeks[-1]
+    nets = [w["mm_net"] for w in weeks]
+    lo, hi = min(nets), max(nets)
+    index = round((last["mm_net"] - lo) / (hi - lo) * 100) if hi > lo and len(weeks) >= 52 else None
+    return {
+        "as_of": last["date"],
+        "open_interest": last["oi"],
+        "managed_money_long": last["mm_long"],
+        "managed_money_short": last["mm_short"],
+        "managed_money_net": last["mm_net"],
+        "net_change_1w": last["mm_net"] - weeks[-2]["mm_net"] if len(weeks) > 1 else None,
+        "net_pct_oi": round(last["mm_net"] / last["oi"] * 100, 1) if last["oi"] else None,
+        "producer_net": last["prod_net"],
+        "index_3y": index,
+        "reading": reading(index),
+        "history": [w["mm_net"] for w in weeks[-52:]],
+    }
+
+
+def build(fetch: Fetch = _fetch, use_cache: bool = True, today: Optional[date] = None) -> dict:
+    if use_cache:
+        with _lock:
+            hit = _cache.get("all")
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            return hit[1]
+
+    since = (today or date.today()) - timedelta(days=365 * YEARS + 7)
+    try:
+        raw = fetch([code for *_, code in MARKETS], since)
+    except Exception as exc:
+        logger.warning("CFTC commitments of traders fetch failed: %s", exc)
+        raw = []
+
+    by_code: dict[str, list[dict]] = {}
+    for r in raw:
+        by_code.setdefault(r.get("cftc_contract_market_code", "").strip(), []).append(r)
+
+    items = []
+    for ticker, label, code in MARKETS:
+        s = summarise(by_code.get(code, []))
+        if s:
+            items.append({"key": ticker, "label": label, **s})
+
+    out = {
+        "items": items,
+        "as_of": max((i["as_of"] for i in items), default=None),
+        "source": "CFTC Commitments of Traders (disaggregated, futures only); positions as of Tuesday, "
+                  "published Friday. Managed money = hedge funds and commodity trading advisers",
+    }
+    if use_cache and items:
+        with _lock:
+            _cache["all"] = (time.time(), out)
+    return out

marketmyna/services/country_macro.py

@@ -0,0 +1,135 @@
+"""Country macro from the IMF World Economic Outlook (DataMapper API, no key).
+
+Real GDP growth, inflation, unemployment, government debt and fiscal balance,
+current account, GDP and GDP per capita for any of about 200 economies, as
+last year / this year / next year, where this year and later are IMF
+projections. One request per indicator returns every country, so the whole
+set is fetched at most once a day and kept on disk; a failed refresh serves
+the saved copy marked stale.
+
+India's figures are fiscal years (April to March), as the IMF reports them.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from datetime import date
+from pathlib import Path
+from typing import Callable, Optional
+
+from marketmyna.core.home import app_home
+
+logger = logging.getLogger(__name__)
+
+API = "https://www.imf.org/external/datamapper/api/v1"
+REFRESH_SECONDS = 24 * 3600
+
+# IMF code, label, unit, note
+INDICATORS = [
+    ("NGDP_RPCH", "GDP growth", "%", "Real GDP, change on the year before"),
+    ("PCPIPCH", "Inflation", "%", "Average consumer prices, change on the year before"),
+    ("LUR", "Unemployment", "%", "Share of the labour force"),
+    ("GGXWDG_NGDP", "Govt debt", "% of GDP", "General government gross debt"),
+    ("GGXCNL_NGDP", "Fiscal balance", "% of GDP", "General government net lending (+) / borrowing (-)"),
+    ("BCA_NGDPD", "Current account", "% of GDP", "Surplus (+) or deficit (-) with the rest of the world"),
+    ("NGDPD", "GDP", "US$ bn", "Nominal GDP in current US dollars"),
+    ("NGDPDPC", "GDP per person", "US$", "Nominal GDP per capita in current US dollars"),
+]
+DEFAULT_COUNTRIES = ["IND", "USA", "CHN", "JPN", "DEU", "GBR", "FRA", "KOR", "IDN", "BRA", "SAU", "ARE", "AUS", "CAN"]
+FISCAL_YEAR = {"IND": "April-March fiscal years"}
+
+Fetch = Callable[[str], dict]
+
+_lock = threading.Lock()
+_state: dict[str, object] = {}
+
+
+def _dir() -> Path:
+    path = app_home() / "imf"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _get(path: str) -> dict:
+    # The IMF's bot filter answers 403 to some clients (browser-like user
+    # agents from scripts); curl_cffi (installed with yfinance) presents a
+    # real browser handshake and is let through.
+    from curl_cffi import requests as cffi
+
+    r = cffi.get(f"{API}/{path}", timeout=30, impersonate="chrome")
+    r.raise_for_status()
+    return r.json() or {}
+
+
+def _download(fetch: Fetch) -> dict:
+    def one(code: str):
+        return code, ((fetch(code).get("values") or {}).get(code)) or {}
+
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        values = dict(pool.map(one, [c for c, *_ in INDICATORS]))
+    if not any(values.values()):
+        raise ValueError("IMF returned no data")
+    names = {k: v.get("label") for k, v in ((fetch("countries").get("countries")) or {}).items() if v.get("label")}
+    return {"values": values, "countries": names, "fetched": time.time()}
+
+
+def _data(fetch: Fetch, now: Optional[float] = None) -> tuple[dict, bool]:
+    """(data, stale). Memory, then disk, then the IMF once a day."""
+    now = now or time.time()
+    with _lock:
+        data = _state.get("data")
+    if data is None:
+        try:
+            data = json.loads((_dir() / "weo.json").read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            data = None
+    if data is not None and now - data.get("fetched", 0) < REFRESH_SECONDS:
+        with _lock:
+            _state["data"] = data
+        return data, False
+    try:
+        fresh = _download(fetch)
+    except Exception as exc:  # noqa: BLE001 - keep serving the saved copy
+        logger.warning("IMF DataMapper fetch failed: %s", exc)
+        if data is None:
+            raise
+        return data, True
+    try:
+        (_dir() / "weo.json").write_text(json.dumps(fresh), encoding="utf-8")
+    except OSError as exc:
+        logger.warning("Could not save IMF data: %s", exc)
+    with _lock:
+        _state["data"] = fresh
+    return fresh, False
+
+
+def build(countries: Optional[list[str]] = None, fetch: Fetch = _get, today: Optional[date] = None) -> dict:
+    year = (today or date.today()).year
+    years = [year - 1, year, year + 1]
+    data, stale = _data(fetch)
+    names: dict = data.get("countries") or {}
+    codes = [c.upper() for c in (countries or DEFAULT_COUNTRIES) if c.upper() in names][:30]
+    rows = []
+    for code in codes:
+        row = {"code": code, "name": names[code], "fiscal_year": FISCAL_YEAR.get(code)}
+        for ind, *_ in INDICATORS:
+            series = (data["values"].get(ind) or {}).get(code) or {}
+            row[ind] = [series.get(str(y)) for y in years]
+            # a 5-year look back for the growth / inflation sparkline
+            row[f"{ind}_trend"] = [{"year": y, "value": series.get(str(y))} for y in range(year - 6, year + 2)
+                                   if series.get(str(y)) is not None]
+        rows.append(row)
+    return {
+        "years": years,
+        "projection_from": year,
+        "indicators": [{"key": c, "label": label, "unit": unit, "note": note} for c, label, unit, note in INDICATORS],
+        "rows": rows,
+        "countries": sorted(({"code": k, "name": v} for k, v in names.items()), key=lambda c: c["name"]),
+        "stale": stale,
+        "as_of": time.strftime("%Y-%m-%d", time.localtime(data.get("fetched", time.time()))),
+        "source": "IMF World Economic Outlook (DataMapper)",
+    }

marketmyna/services/crude_sensitivity.py

@@ -0,0 +1,239 @@
+"""How oil-linked stocks react to crude - India, US, Hong Kong, China A.
+
+For each stock, weekly returns over two years are regressed on the local
+index and on crude in local currency together (India: Nifty 50 and Brent
+in rupees; US: S&P 500 and WTI; HK: Hang Seng and Brent; China: Shanghai Composite
+and Brent in yuan):
+
+    r_stock = a + b_mkt * r_index + b_crude * r_crude_local + e
+
+b_crude is the crude sensitivity net of the market: a b_crude of -0.3 means a
+10% rise in rupee Brent has gone with the stock doing about 3% worse than its
+market exposure alone would suggest. Weekly bars sidestep the time-zone gap
+between NSE and ICE closes. Plain numpy OLS with ordinary standard errors.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from typing import Callable, Optional
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+CACHE_SECONDS = 6 * 3600
+BRENT, FX, NIFTY = "BZ=F", "USDINR=X", "^NSEI"
+
+# group, why it is linked to crude, [(symbol, name)]
+GROUPS = [
+    ("Oil marketing (OMCs)", "Buy crude, sell fuel at prices the government leans on: costlier crude squeezes margins",
+     [("BPCL", "Bharat Petroleum"), ("HINDPETRO", "Hindustan Petroleum"), ("IOC", "Indian Oil")]),
+    ("Upstream producers", "Sell the crude they pump: higher prices lift revenue (windfall taxes cap it)",
+     [("ONGC", "ONGC"), ("OIL", "Oil India")]),
+    ("Refining & petchem", "Margins track the spread between crude and products",
+     [("RELIANCE", "Reliance Industries"), ("MRPL", "MRPL"), ("CHENNPETRO", "Chennai Petroleum")]),
+    ("Paints", "Many raw materials are crude derivatives",
+     [("ASIANPAINT", "Asian Paints"), ("BERGEPAINT", "Berger Paints"), ("KANSAINER", "Kansai Nerolac")]),
+    ("Aviation", "Jet fuel is the largest cost line",
+     [("INDIGO", "InterGlobe Aviation")]),
+    ("Tyres", "Synthetic rubber and carbon black come from crude",
+     [("MRF", "MRF"), ("APOLLOTYRE", "Apollo Tyres"), ("CEATLTD", "CEAT")]),
+    ("Gas", "City gas buys LNG priced partly off crude and sells at regulated prices; GAIL also trades it",
+     [("IGL", "Indraprastha Gas"), ("MGL", "Mahanagar Gas"), ("GAIL", "GAIL")]),
+]
+
+US_GROUPS = [
+    ("Integrated majors", "Pump, refine and sell: revenue rides the crude price, refining softens it",
+     [("XOM", "Exxon Mobil"), ("CVX", "Chevron")]),
+    ("Producers (E&P)", "Sell the crude they pump: the purest upside to higher oil",
+     [("COP", "ConocoPhillips"), ("EOG", "EOG Resources"), ("OXY", "Occidental"), ("DVN", "Devon Energy")]),
+    ("Oil services", "Drilling budgets follow the oil price with a lag",
+     [("SLB", "SLB"), ("HAL", "Halliburton"), ("BKR", "Baker Hughes")]),
+    ("Refiners", "Margins track the spread between crude and fuel, not crude itself",
+     [("VLO", "Valero"), ("MPC", "Marathon Petroleum"), ("PSX", "Phillips 66")]),
+    ("Airlines", "Jet fuel is one of the two biggest costs",
+     [("DAL", "Delta"), ("UAL", "United"), ("AAL", "American"), ("LUV", "Southwest")]),
+    ("Cruise lines", "Bunker fuel is a big cost and higher pump prices squeeze customers",
+     [("CCL", "Carnival"), ("RCL", "Royal Caribbean"), ("NCLH", "Norwegian Cruise")]),
+    ("Chemicals", "Feedstock is oil and gas derivatives",
+     [("DOW", "Dow"), ("LYB", "LyondellBasell")]),
+    ("Parcel & trucking", "Diesel and jet fuel costs, partly passed on through surcharges",
+     [("UPS", "UPS"), ("FDX", "FedEx"), ("ODFL", "Old Dominion")]),
+]
+
+HK_GROUPS = [
+    ("Oil majors", "China's big three: upstream profits rise with crude, refining and retail cushion it",
+     [("00857", "PetroChina"), ("00386", "Sinopec"), ("00883", "CNOOC")]),
+    ("Airlines", "Jet fuel is one of the largest costs",
+     [("00293", "Cathay Pacific"), ("00753", "Air China"), ("00670", "China Eastern"), ("01055", "China Southern")]),
+    ("Shipping", "Bunker fuel costs; freight rates often move with energy demand",
+     [("01919", "COSCO Shipping"), ("00316", "OOIL"), ("02866", "COSCO Shipping Dev")]),
+    ("City gas", "Buy gas priced partly off oil, sell at regulated tariffs",
+     [("00003", "HK & China Gas"), ("01193", "China Resources Gas"), ("02688", "ENN Energy")]),
+]
+
+CHINA_GROUPS = [
+    ("Oil majors", "Upstream profits rise with crude; state-set fuel prices cap the refining side",
+     [("601857", "PetroChina"), ("600028", "Sinopec"), ("600938", "CNOOC")]),
+    ("Oilfield services", "Spending follows the oil price",
+     [("600871", "Sinopec Oilfield"), ("601808", "China Oilfield Services")]),
+    ("Airlines", "Jet fuel is one of the largest costs",
+     [("601111", "Air China"), ("600115", "China Eastern"), ("600029", "China Southern")]),
+    ("Chemicals & refining", "Crude is the feedstock",
+     [("600309", "Wanhua Chemical"), ("002493", "Rongsheng Petrochem"), ("600346", "Hengli Petrochem")]),
+]
+
+# market -> index, crude contract, FX to local (None = priced in USD), labels.
+# Group symbols are the app's own (00857, 601857); yahoo_symbol maps them.
+MARKETS = {
+    "india": {"index": NIFTY, "index_name": "Nifty 50", "crude": BRENT, "crude_name": "Brent", "fx": FX,
+              "currency": "₹", "groups": GROUPS},
+    "us": {"index": "^GSPC", "index_name": "S&P 500", "crude": "CL=F", "crude_name": "WTI", "fx": None,
+           "currency": "$", "groups": US_GROUPS},
+    "hong_kong": {"index": "^HSI", "index_name": "Hang Seng", "crude": BRENT, "crude_name": "Brent", "fx": "HKD=X",
+                  "currency": "HK$", "groups": HK_GROUPS},
+    "china_a": {"index": "000001.SS", "index_name": "Shanghai Composite", "crude": BRENT, "crude_name": "Brent", "fx": "CNY=X",
+                "currency": "¥", "groups": CHINA_GROUPS},
+}
+
+Fetch = Callable[[list[str]], dict[str, pd.Series]]
+
+_cache: dict[str, tuple[float, dict]] = {}
+_lock = threading.Lock()
+
+
+def _yahoo(tickers: list[str]) -> dict[str, pd.Series]:
+    import yfinance as yf
+
+    from ..data import ecb_fx
+    from ..utils.yf_lock import YF_DOWNLOAD_LOCK
+
+    def download() -> dict[str, pd.Series]:
+        with YF_DOWNLOAD_LOCK:
+            df = yf.download(tickers, period="2y", interval="1d", progress=False, auto_adjust=True, threads=True)
+        closes = df["Close"]
+        return {t: closes[t].dropna() for t in tickers if t in closes and closes[t].notna().sum()}
+
+    return ecb_fx.guarded(download, tickers)
+
+
+def _weekly(s: pd.Series) -> pd.Series:
+    s = s.copy()
+    s.index = pd.DatetimeIndex(s.index).tz_localize(None) if getattr(s.index, "tz", None) else pd.DatetimeIndex(s.index)
+    return s.resample("W-FRI").last()
+
+
+def regress(stock: pd.Series, nifty: pd.Series, crude: pd.Series) -> Optional[dict]:
+    """Weekly two-factor OLS. Inputs are daily closes."""
+    df = pd.concat([_weekly(stock), _weekly(nifty), _weekly(crude)], axis=1, keys=["s", "m", "c"]).pct_change().dropna()
+    if len(df) < 40:
+        return None
+    y = df["s"].to_numpy()
+    x = np.column_stack([np.ones(len(df)), df["m"].to_numpy(), df["c"].to_numpy()])
+    beta, *_ = np.linalg.lstsq(x, y, rcond=None)
+    resid = y - x @ beta
+    dof = len(y) - x.shape[1]
+    s2 = float(resid @ resid) / dof
+    se = np.sqrt(np.diag(s2 * np.linalg.inv(x.T @ x)))
+    tss = float(((y - y.mean()) ** 2).sum())
+    r2 = 1 - float(resid @ resid) / tss if tss else None
+    # R2 of the market-only model, to show what crude adds
+    xm = x[:, :2]
+    bm, *_ = np.linalg.lstsq(xm, y, rcond=None)
+    rm = y - xm @ bm
+    r2_mkt = 1 - float(rm @ rm) / tss if tss else None
+    t = float(beta[2] / se[2]) if se[2] else 0.0
+    return {
+        "weeks": len(df),
+        "beta_market": float(beta[1]),
+        "beta_crude": float(beta[2]),
+        "t_crude": t,
+        "significant": abs(t) >= 2,
+        "corr_crude": float(np.corrcoef(df["s"], df["c"])[0, 1]),
+        "r2": r2,
+        "r2_added": (r2 - r2_mkt) if r2 is not None and r2_mkt is not None else None,
+    }
+
+
+def _change(s: pd.Series, days: int) -> Optional[float]:
+    s = s.dropna()
+    if s.empty:
+        return None
+    idx = pd.DatetimeIndex(s.index).tz_localize(None) if getattr(s.index, "tz", None) else pd.DatetimeIndex(s.index)
+    s = pd.Series(s.to_numpy(), index=idx)
+    past = s[s.index <= s.index[-1] - pd.Timedelta(days=days)]
+    return float(s.iloc[-1] / past.iloc[-1] - 1) * 100 if len(past) else None
+
+
+def build(fetch: Fetch = _yahoo, use_cache: bool = True, market: str = "india") -> dict:
+    cfg = MARKETS.get(market)
+    if cfg is None:
+        return {"groups": [], "market": market, "error": "Oil sensitivity is not available for this market"}
+    if use_cache:
+        with _lock:
+            hit = _cache.get(market)
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            return hit[1]
+
+    index, crude_t, fx = cfg["index"], cfg["crude"], cfg["fx"]
+    from .analysis_run import yahoo_symbol
+
+    tickers = [yahoo_symbol(sym, market) for _, _, members in cfg["groups"] for sym, _ in members]
+    tickers += [crude_t, index] + ([fx] if fx else [])
+    try:
+        data = fetch(tickers)
+    except Exception as exc:
+        logger.warning("Crude sensitivity fetch failed: %s", exc)
+        return {"groups": [], "market": market, "error": "Price data unavailable right now"}
+    if crude_t not in data or index not in data or (fx and fx not in data):
+        return {"groups": [], "market": market, "error": f"{cfg['crude_name']}, FX or {cfg['index_name']} history unavailable"}
+
+    if fx:
+        both = pd.concat([data[crude_t], data[fx]], axis=1, keys=["b", "fx"]).ffill().dropna()
+        crude_local = both["b"] * both["fx"]
+    else:
+        crude_local = data[crude_t]
+    crude_1m = _change(crude_local, 30)
+
+    groups = []
+    for name, why, members in cfg["groups"]:
+        rows = []
+        for sym, label in members:
+            s = data.get(yahoo_symbol(sym, market))
+            if s is None:
+                continue
+            r = regress(s, data[index], crude_local)
+            if r is None:
+                continue
+            r.update(symbol=sym, name=label,
+                     change_1m=_change(s, 30),
+                     # what crude's last month implies on its own, holding the market flat
+                     crude_implied_1m=r["beta_crude"] * crude_1m if crude_1m is not None else None)
+            rows.append(r)
+        if rows:
+            groups.append({"name": name, "why": why,
+                           "avg_beta_crude": float(np.mean([r["beta_crude"] for r in rows])),
+                           "stocks": rows})
+    local = "" if not fx else {"india": " in rupees", "hong_kong": " in HK dollars", "china_a": " in yuan"}[market]
+    crude_label = f"{cfg['crude_name']}{local}"
+    out = {
+        "market": market,
+        "groups": groups,
+        "crude_label": crude_label,
+        "currency": cfg["currency"],
+        "index_name": cfg["index_name"],
+        "crude": float(crude_local.iloc[-1]),
+        "crude_change_1m": crude_1m,
+        "crude_change_1y": _change(crude_local, 365),
+        "method": f"Weekly returns over 2 years, regressed on the {cfg['index_name']} and {crude_label} together.",
+    }
+    if market == "india":  # older field names, kept for existing clients
+        out.update(brent_inr=out["crude"], brent_inr_change_1m=crude_1m, brent_inr_change_1y=out["crude_change_1y"])
+    if use_cache and groups:
+        with _lock:
+            _cache[market] = (time.time(), out)
+    return out

marketmyna/services/crypto_mood.py

@@ -0,0 +1,135 @@
+"""Crypto market mood: the stock gauge's idea (marketmyna/services/market_mood.py)
+for coins, which have no 52-week history in our feed, no index and no VIX.
+
+Universe: the most-traded coins of the crypto screens (stablecoins dropped),
+six months of daily closes shared with them. Readings, each 0 (fear) - 100 (greed):
+
+- Advancing vs declining today (24h change of each coin)
+- Share above the 50-day average
+- Share above the 100-day average
+- Near 90-day highs vs lows (within 5% of either; share that are highs)
+- Bitcoin vs its 125-day average (-20% -> 0, +20% -> 100; coins swing more than indices)
+- Bitcoin's 30-day volatility vs its past months (calm = high score)
+- Perpetual funding (BTC and ETH, annualised): about 11%/yr is the usual
+  baseline; crowded longs push it up (greed), crowded shorts below zero (fear)
+
+Describes how the market behaves now; not a forecast or advice.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import threading
+import time
+from typing import Callable, Optional
+
+import pandas as pd
+
+from . import crypto_screens
+from .market_mood import _clip, label
+
+logger = logging.getLogger(__name__)
+
+CACHE_SECONDS = 300
+FUNDING_BASELINE = 11.0  # % / yr: 0.01% per 8h, the exchanges' default
+
+_cache: dict[str, tuple[float, Optional[float]]] = {}
+_lock = threading.Lock()
+
+
+def _funding() -> Optional[float]:
+    """Average annualised BTC / ETH perpetual funding in %, or None."""
+    from .rates import _funding_binance, _funding_bybit
+
+    for fn in (_funding_binance, _funding_bybit):
+        try:
+            rows = [r for r in fn() if r["coin"] in ("BTC", "ETH")]
+        except Exception as exc:
+            logger.warning("Funding for crypto mood via %s failed: %s", fn.__name__, exc)
+            continue
+        if rows:
+            return sum(r["rate_8h"] for r in rows) / len(rows) * 3 * 365 * 100
+    return None
+
+
+def readings(coins: dict[str, pd.Series], changes: list[float], btc: Optional[pd.Series],
+             funding: Optional[float]) -> list[dict]:
+    out = []
+    adv = sum(1 for c in changes if c > 0)
+    dec = sum(1 for c in changes if c < 0)
+    if adv + dec:
+        out.append({"key": "breadth", "label": "Advancing vs declining (24h)", "score": _clip(adv / (adv + dec) * 100),
+                    "value": f"{adv} up, {dec} down"})
+
+    for days in (50, 100):
+        ok = [s for s in coins.values() if len(s) >= days]
+        if len(ok) >= 20:
+            above = sum(1 for s in ok if s.iloc[-1] > s.iloc[-days:].mean())
+            out.append({"key": f"above_{days}", "label": f"Above the {days}-day average", "score": _clip(above / len(ok) * 100),
+                        "value": f"{above} of {len(ok)} ({above / len(ok):.0%})"})
+
+    ok = [s for s in coins.values() if len(s) >= 90]
+    if len(ok) >= 20:
+        highs = sum(1 for s in ok if s.iloc[-1] >= s.iloc[-90:].max() * 0.95)
+        lows = sum(1 for s in ok if s.iloc[-1] <= s.iloc[-90:].min() * 1.05)
+        out.append({"key": "highs_lows", "label": "Near 90-day highs vs lows",
+                    "score": _clip(highs / (highs + lows) * 100) if highs + lows else 50.0,
+                    "value": f"{highs} near highs, {lows} near lows" if highs + lows else "none near a high or a low"})
+
+    if btc is not None and len(btc) >= 125:
+        gap = float(btc.iloc[-1] / btc.iloc[-125:].mean() - 1)
+        out.append({"key": "momentum", "label": "Bitcoin vs its 125-day average", "score": _clip(50 + gap * 250),
+                    "value": f"{gap:+.1%}"})
+
+    if btc is not None and len(btc) >= 90:
+        vol = btc.pct_change().rolling(30).std().dropna() * math.sqrt(365) * 100
+        if len(vol) >= 30:
+            now = float(vol.iloc[-1])
+            rank = float((vol < now).mean())
+            out.append({"key": "volatility", "label": "Bitcoin volatility vs recent months", "score": _clip((1 - rank) * 100),
+                        "value": f"{now:.0f}%/yr, higher than {rank:.0%} of the period"})
+
+    if funding is not None:
+        out.append({"key": "funding", "label": "Funding rates (BTC, ETH)", "score": _clip(50 + (funding - FUNDING_BASELINE) * 2.5),
+                    "value": f"{funding:+.1f}% / yr"})
+    return out
+
+
+def _funding_cached(funding: Callable[[], Optional[float]], use_cache: bool) -> Optional[float]:
+    if use_cache:
+        with _lock:
+            hit = _cache.get("funding")
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            return hit[1]
+    value = funding()
+    if use_cache and value is not None:
+        with _lock:
+            _cache["funding"] = (time.time(), value)
+    return value
+
+
+def build(rows: Optional[list[dict]] = None, fetch: Callable = crypto_screens._fetch,
+          funding: Callable[[], Optional[float]] = _funding, use_cache: bool = True) -> dict:
+    """`rows` = the crypto listing, ideally with live prices merged in: today's
+    breadth follows them on every call; closes and funding are cached."""
+    if rows is None:
+        from ..data.listings import get_store
+
+        rows = get_store().rows("crypto")
+    coins = crypto_screens.universe(rows)
+    closes = crypto_screens.history(coins, fetch, use_cache)
+    series = {c["symbol"]: closes[c["symbol"]] for c in coins if c["symbol"] in closes}
+    changes = [float(c["change_percent"]) for c in coins if c.get("change_percent") is not None]
+    parts = readings(series, changes, closes.get("BTC-USD"), _funding_cached(funding, use_cache))
+    score = round(sum(p["score"] for p in parts) / len(parts), 1) if parts else None
+    for p in parts:
+        p["score"] = round(p["score"], 1)
+        p["label_text"] = label(p["score"])
+    out = {
+        "market": "crypto", "score": score, "label": label(score), "readings": parts,
+        "universe": f"the {len(series)} most-traded coins (stablecoins excluded)",
+        "index": "Bitcoin",
+        "source": "Daily closes from crypto exchange data; today's moves and funding from live exchange data",
+    }
+    return out