marketmyna 0.2.0__py3-none-any.whl

marketmyna/services/central_banks.py

@@ -0,0 +1,202 @@
+"""Central-bank policy rates for about 40 economies (BIS, no key).
+
+From the BIS daily policy-rate series: today's rate, when it last changed
+and from what, the change over a year, and the real rate against the IMF's
+inflation projection for this year (marketmyna/services/country_macro.py). Kept
+on disk for 12 hours; a failed refresh serves the saved copy marked stale.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import logging
+import threading
+import time
+from datetime import date, timedelta
+from pathlib import Path
+from typing import Callable, Optional
+
+import requests
+
+from marketmyna.core.home import app_home
+
+logger = logging.getLogger(__name__)
+
+URL = "https://stats.bis.org/api/v1/data/WS_CBPOL/D./all"
+REFRESH_SECONDS = 12 * 3600
+
+# BIS area -> (IMF code, central bank)
+AREAS = {
+    "US": ("USA", "Federal Reserve"), "XM": ("", "European Central Bank"), "GB": ("GBR", "Bank of England"),
+    "JP": ("JPN", "Bank of Japan"), "CN": ("CHN", "People's Bank of China"), "IN": ("IND", "Reserve Bank of India"),
+    "CA": ("CAN", "Bank of Canada"), "AU": ("AUS", "Reserve Bank of Australia"), "CH": ("CHE", "Swiss National Bank"),
+    "KR": ("KOR", "Bank of Korea"), "BR": ("BRA", "Central Bank of Brazil"), "MX": ("MEX", "Bank of Mexico"),
+    "ID": ("IDN", "Bank Indonesia"), "ZA": ("ZAF", "South African Reserve Bank"), "TR": ("TUR", "Central Bank of Türkiye"),
+    "RU": ("RUS", "Bank of Russia"), "SA": ("SAU", "Saudi Central Bank"), "HK": ("HKG", "Hong Kong Monetary Authority"),
+    "SE": ("SWE", "Riksbank"), "NO": ("NOR", "Norges Bank"), "DK": ("DNK", "Danmarks Nationalbank"),
+    "NZ": ("NZL", "Reserve Bank of New Zealand"), "PL": ("POL", "National Bank of Poland"),
+    "CZ": ("CZE", "Czech National Bank"), "HU": ("HUN", "Magyar Nemzeti Bank"), "RO": ("ROU", "National Bank of Romania"),
+    "IL": ("ISR", "Bank of Israel"), "TH": ("THA", "Bank of Thailand"), "MY": ("MYS", "Bank Negara Malaysia"),
+    "PH": ("PHL", "Bangko Sentral ng Pilipinas"), "CL": ("CHL", "Central Bank of Chile"),
+    "CO": ("COL", "Central Bank of Colombia"), "PE": ("PER", "Central Reserve Bank of Peru"),
+    "AR": ("ARG", "Central Bank of Argentina"), "IS": ("ISL", "Central Bank of Iceland"),
+    "KW": ("KWT", "Central Bank of Kuwait"), "MA": ("MAR", "Bank Al-Maghrib"), "RS": ("SRB", "National Bank of Serbia"),
+    "MK": ("MKD", "National Bank of North Macedonia"),
+}
+FIRST = ["IN", "US", "XM", "GB", "JP", "CN"]  # shown first; the rest by name
+
+Fetch = Callable[[str], str]
+
+_lock = threading.Lock()
+_state: dict[str, object] = {}
+
+
+def _dir() -> Path:
+    path = app_home() / "bis"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _get(start: str) -> str:
+    r = requests.get(URL, params={"startPeriod": start, "format": "csv"}, timeout=60)
+    r.raise_for_status()
+    return r.text
+
+
+def parse(text: str) -> dict[str, dict]:
+    """{area: {"name": ..., "points": [(date, rate), ...]}} oldest first, gaps dropped."""
+    out: dict[str, dict] = {}
+    for row in csv.DictReader(io.StringIO(text)):
+        try:
+            value = float(row["OBS_VALUE"])
+        except (TypeError, ValueError):
+            continue
+        if value != value:  # NaN
+            continue
+        area = row["REF_AREA"]
+        title = (row.get("TITLE") or "").split(" - ")
+        item = out.setdefault(area, {"name": title[1].strip() if len(title) > 1 else area, "points": []})
+        item["points"].append((row["TIME_PERIOD"], value))
+    for item in out.values():
+        item["points"].sort()
+    return out
+
+
+def _data(fetch: Fetch, today: date) -> tuple[dict, bool]:
+    with _lock:
+        data = _state.get("data")
+    if data is None:
+        try:
+            data = json.loads((_dir() / "policy-rates.json").read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            data = None
+    if data is not None and time.time() - data.get("fetched", 0) < REFRESH_SECONDS:
+        with _lock:
+            _state["data"] = data
+        return data, False
+    try:
+        areas = parse(fetch((today - timedelta(days=730)).isoformat()))
+        if not areas:
+            raise ValueError("BIS returned no rates")
+        fresh = {"areas": areas, "fetched": time.time()}
+    except Exception as exc:  # noqa: BLE001 - serve the saved copy
+        logger.warning("BIS policy rates failed: %s", exc)
+        if data is None:
+            raise
+        return data, True
+    try:
+        (_dir() / "policy-rates.json").write_text(json.dumps(fresh), encoding="utf-8")
+    except OSError as exc:
+        logger.warning("Could not save policy rates: %s", exc)
+    with _lock:
+        _state["data"] = fresh
+    return fresh, False
+
+
+def _inflation(year: int) -> dict[str, float]:
+    """IMF inflation projection for this year by IMF code, if already loaded (never blocks on the IMF)."""
+    try:
+        from . import country_macro
+
+        with country_macro._lock:
+            data = country_macro._state.get("data")
+        if data is None:
+            data = json.loads((country_macro._dir() / "weo.json").read_text(encoding="utf-8"))
+        series = (data.get("values") or {}).get("PCPIPCH") or {}
+        return {code: v[str(year)] for code, v in series.items() if v.get(str(year)) is not None}
+    except Exception:  # noqa: BLE001 - the real rate is an extra
+        return {}
+
+
+def _rbi_repo() -> Optional[tuple[str, float]]:
+    """(date, repo rate) from the RBI page snapshot marketmyna/services/india_rates.py
+    keeps; the BIS series for India can lag the RBI by months."""
+    try:
+        from . import india_rates
+
+        path = india_rates._dir() / "rbi.json"
+        if not path.exists() or time.time() - path.stat().st_mtime > 86400:
+            india_rates.build()  # refreshes the snapshot (it has its own cache and fallback)
+        data = json.loads(path.read_text(encoding="utf-8"))
+        repo = next(p["value"] for p in data.get("policy") or [] if p.get("key") == "repo")
+        return str(data.get("fetched_at") or "")[:10], float(repo)
+    except Exception:  # noqa: BLE001 - BIS alone is fine
+        return None
+
+
+def with_rbi(points: list, rbi: Optional[tuple[str, float]]) -> list:
+    """Append the RBI's own reading when it is newer than the BIS series."""
+    if rbi and rbi[0] and (not points or rbi[0] > points[-1][0]):
+        return [*points, rbi]
+    return points
+
+
+def summarise(area: str, name: str, points: list, today: date, inflation: dict[str, float]) -> Optional[dict]:
+    if not points:
+        return None
+    as_of, rate = points[-1]
+    changed, previous = None, None
+    for when, value in reversed(points):
+        if value != rate:
+            previous = value
+            break
+        changed = when
+    year_ago = [v for d, v in points if d <= (today - timedelta(days=365)).isoformat()]
+    imf, bank = AREAS.get(area, ("", ""))
+    infl = inflation.get(imf) if imf else None
+    monthly: dict[str, float] = {}
+    for when, value in points:
+        monthly[when[:7]] = value  # month-end value
+    return {
+        "area": area, "name": name, "bank": bank, "rate": rate, "as_of": as_of,
+        "last_change": changed if previous is not None else None, "previous": previous,
+        "direction": None if previous is None else ("cut" if rate < previous else "hike"),
+        "change_1y": round(rate - year_ago[-1], 3) if year_ago else None,
+        "inflation": infl, "real_rate": round(rate - infl, 2) if infl is not None else None,
+        "spark": [{"month": m, "rate": v} for m, v in monthly.items()],
+    }
+
+
+def build(fetch: Fetch = _get, today: Optional[date] = None) -> dict:
+    today = today or date.today()
+    data, stale = _data(fetch, today)
+    inflation = _inflation(today.year)
+    rbi = _rbi_repo()
+    rows = []
+    for area, item in (data.get("areas") or {}).items():
+        points = [tuple(p) for p in item["points"]]
+        bis_last = points[-1] if points else None
+        if area == "IN":
+            points = with_rbi(points, rbi)
+        if r := summarise(area, item["name"], points, today, inflation):
+            if bis_last and points[-1] != bis_last and points[-1][1] != bis_last[1]:
+                # moved between the last BIS day and the RBI reading: exact date unknown
+                r["last_change"], r["changed_between"] = None, [bis_last[0], points[-1][0]]
+            rows.append(r)
+    rows.sort(key=lambda r: (FIRST.index(r["area"]) if r["area"] in FIRST else len(FIRST), r["name"]))
+    return {"rows": rows, "stale": stale,
+            "as_of": time.strftime("%Y-%m-%d", time.localtime(data.get("fetched", time.time()))),
+            "source": "BIS central bank policy rates (India: RBI's own page when newer); real rate uses the IMF inflation projection for "
+                      f"{today.year}"}

marketmyna/services/commodities.py

@@ -0,0 +1,134 @@
+"""Commodities snapshot: front-month futures from Yahoo (no key) with 1-day,
+1-month and 1-year change and a 3-month sparkline, plus gold and silver in
+rupees for Indian users. Covers the useful core of OpenBB's commodity
+endpoints. CFTC positioning (cot.py) and EIA oil stocks (eia_stocks.py) are
+separate endpoints the card loads after the prices.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from typing import Callable, Optional
+
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+CACHE_SECONDS = 15 * 60
+TROY_OZ_G = 31.1034768
+
+# ticker, label, group, unit, note
+ITEMS = [
+    ("GC=F", "Gold", "metals", "$/oz", "Safe-haven; tends to rise when real interest rates fall"),
+    ("SI=F", "Silver", "metals", "$/oz", "Part precious, part industrial metal"),
+    ("HG=F", "Copper", "metals", "$/lb", "Industrial demand gauge (\"Dr Copper\")"),
+    ("CL=F", "WTI crude", "energy", "$/bbl", "US oil benchmark"),
+    ("BZ=F", "Brent crude", "energy", "$/bbl", "Global oil benchmark; India's import bill moves with it"),
+    ("NG=F", "Natural gas", "energy", "$/MMBtu", "US Henry Hub gas"),
+    ("ZW=F", "Wheat", "agri", "¢/bu", "CBOT wheat"),
+    ("ZC=F", "Corn", "agri", "¢/bu", "CBOT corn"),
+]
+FX = "USDINR=X"
+
+Fetch = Callable[[list[str]], dict[str, pd.Series]]
+
+_cache: dict[str, tuple[float, dict]] = {}
+_raw_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]:
+        # 2y, not 1y: a 1-year window ending at a bar dated yesterday has no bar a
+        # full year back, so the 1-year change would come out empty.
+        with YF_DOWNLOAD_LOCK:
+            df = yf.download(tickers, period="2y", interval="1d", progress=False, auto_adjust=False, threads=True)
+        closes = df["Close"] if isinstance(df.columns, pd.MultiIndex) else df[["Close"]].rename(columns={"Close": tickers[0]})
+        return {t: closes[t].dropna() for t in tickers if t in closes and closes[t].notna().sum()}
+
+    # Currency pairs Yahoo misses come from the ECB's daily reference rates
+    return ecb_fx.guarded(download, tickers)
+
+
+def _change(s: pd.Series, days: int) -> Optional[float]:
+    when = s.index[-1] - pd.Timedelta(days=days)
+    past = s[s.index <= when]
+    return float(s.iloc[-1] / past.iloc[-1] - 1) * 100 if len(past) and past.iloc[-1] else None
+
+
+def _row(key: str, label: str, group: str, unit: str, note: str, s: pd.Series) -> dict:
+    spark = s[s.index >= s.index[-1] - pd.Timedelta(days=92)]
+    return {
+        "key": key, "label": label, "group": group, "unit": unit, "note": note,
+        "price": float(s.iloc[-1]),
+        "as_of": str(pd.Timestamp(s.index[-1]).date()),
+        "change_1d": float(s.iloc[-1] / s.iloc[-2] - 1) * 100 if len(s) > 1 and s.iloc[-2] else None,
+        "change_1m": _change(s, 30),
+        "change_1y": _change(s, 365),
+        "spark": [round(float(v), 4) for v in spark.to_numpy()],
+    }
+
+
+def tickers() -> list[str]:
+    return [t for t, *_ in ITEMS] + [FX]
+
+
+def build(fetch: Fetch = _yahoo, use_cache: bool = True, live: Optional[dict] = None) -> dict:
+    """`live`: ticker -> {price, day} from live_market.latest, moving each
+    contract's latest price (and the rupee prices with it); the history
+    behind it is cached CACHE_SECONDS."""
+    from .live_market import extend_all
+
+    if use_cache and not live:
+        with _lock:
+            hit = _cache.get("all")
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            return hit[1]
+
+    data = None
+    if use_cache:
+        with _lock:
+            hit = _raw_cache.get("all")
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            data = hit[1]
+    if data is None:
+        try:
+            data = fetch(tickers())
+        except Exception as exc:  # network / Yahoo hiccup
+            logger.warning("Commodity fetch failed: %s", exc)
+            data = {}
+        if use_cache and data:
+            with _lock:
+                _raw_cache["all"] = (time.time(), data)
+    if live:
+        data = extend_all(data, live)
+
+    rows = [_row(t, label, group, unit, note, data[t]) for t, label, group, unit, note in ITEMS
+            if t in data and len(data[t]) > 1]
+
+    # Gold / silver in rupees: international price x USDINR, before import duty and GST,
+    # so MCX / jeweller prices run a few percent higher.
+    fx = data.get(FX)
+    if fx is not None and len(fx) > 1:
+        for t, label, unit, grams in (("GC=F", "Gold (₹)", "₹/10g", 10), ("SI=F", "Silver (₹)", "₹/kg", 1000)):
+            if t in data:
+                usd = data[t]
+                joined = pd.concat([usd, fx], axis=1, keys=["p", "fx"]).ffill().dropna()
+                inr = joined["p"] * joined["fx"] / TROY_OZ_G * grams
+                if len(inr) > 1:
+                    rows.append(_row(f"{t}:INR", label, "india", unit,
+                                     "International price in rupees, before import duty and GST", inr))
+
+    out = {"items": rows, "updated": time.strftime("%Y-%m-%dT%H:%M:%S"),
+           "usd_inr": float(fx.iloc[-1]) if fx is not None and len(fx) else None}
+    if use_cache and rows and not live:
+        with _lock:
+            _cache["all"] = (time.time(), out)
+    return out

marketmyna/services/compare.py

@@ -0,0 +1,307 @@
+"""Side-by-side comparison of 2-5 instruments, and automatic peer discovery.
+
+Mirrors OpenBB's equity "compare" / "peers" commands with free data: prices
+from Yahoo (adjusted, so dividends are included), fundamentals from Yahoo's
+quote summary, peers from our own listings (same market and sector, nearest in
+size) confirmed against Yahoo's finer "industry" label.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import math
+import os
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Callable, Optional
+
+import pandas as pd
+
+from marketmyna.core.home import app_home
+
+from ..core.numbers import finite as _f
+from ..data.yahoo_price import info_price
+
+logger = logging.getLogger(__name__)
+
+MAX_SYMBOLS = 5
+PERIODS = {"6mo": 182, "1y": 365, "3y": 1095, "5y": 1826}
+RETURN_WINDOWS = [("1M", 30), ("3M", 91), ("6M", 182), ("1Y", 365), ("3Y", 1095), ("5Y", 1826)]
+INFO_TTL = 6 * 3600
+
+# label, yahoo key, kind, higher is better (None = no ranking), group
+METRICS = [
+    ("Market cap", "marketCap", "money", None, "Size & valuation"),
+    ("P/E (trailing)", "trailingPE", "ratio", False, "Size & valuation"),
+    ("P/E (forward)", "forwardPE", "ratio", False, "Size & valuation"),
+    ("PEG", "pegRatio", "ratio", False, "Size & valuation"),
+    ("Price / book", "priceToBook", "ratio", False, "Size & valuation"),
+    ("Price / sales", "priceToSalesTrailing12Months", "ratio", False, "Size & valuation"),
+    ("EV / EBITDA", "enterpriseToEbitda", "ratio", False, "Size & valuation"),
+    ("Revenue growth", "revenueGrowth", "pct", True, "Growth & profitability"),
+    ("Earnings growth", "earningsGrowth", "pct", True, "Growth & profitability"),
+    ("Gross margin", "grossMargins", "pct", True, "Growth & profitability"),
+    ("Operating margin", "operatingMargins", "pct", True, "Growth & profitability"),
+    ("Profit margin", "profitMargins", "pct", True, "Growth & profitability"),
+    ("Return on equity", "returnOnEquity", "pct", True, "Growth & profitability"),
+    ("Return on assets", "returnOnAssets", "pct", True, "Growth & profitability"),
+    ("Debt / equity", "debtToEquity", "ratio", False, "Balance sheet & income"),
+    ("Current ratio", "currentRatio", "ratio", True, "Balance sheet & income"),
+    ("Free cash flow", "freeCashflow", "money", True, "Balance sheet & income"),
+    ("Dividend yield", "dividendYield", "pct_raw", True, "Balance sheet & income"),
+    ("Payout ratio", "payoutRatio", "pct", None, "Balance sheet & income"),
+    ("Analyst target upside", None, "pct_raw", True, "Analysts"),
+    ("Analyst rating (1 buy - 5 sell)", "recommendationMean", "ratio", False, "Analysts"),
+    ("Analysts", "numberOfAnalystOpinions", "count", None, "Analysts"),
+]
+
+InfoFetch = Callable[[str], dict]
+PriceFetch = Callable[[list[str], str], dict[str, pd.Series]]
+
+_info_cache: dict[str, tuple[float, dict]] = {}
+_info_lock = threading.Lock()
+
+
+def _info_file(yf_symbol: str) -> Path:
+    base = Path(os.environ.get("YAHOO_INFO_CACHE_DIR") or app_home() / "cache" / "yahoo_info")
+    return base / (hashlib.sha256(yf_symbol.encode()).hexdigest()[:24] + ".json")
+
+
+def _disk_info(yf_symbol: str) -> Optional[tuple[float, dict]]:
+    """The saved copy, so an API restart or deploy doesn't make every screen
+    and Compare page fetch ~100 stocks from Yahoo again."""
+    try:
+        saved = json.loads(_info_file(yf_symbol).read_text(encoding="utf-8"))
+        return float(saved["at"]), saved["info"]
+    except (OSError, ValueError, KeyError, TypeError):
+        return None
+
+
+def _save_info(yf_symbol: str, at: float, info: dict) -> None:
+    path = _info_file(yf_symbol)
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(".tmp")
+        tmp.write_text(json.dumps({"at": at, "info": info}, default=str), encoding="utf-8")
+        tmp.replace(path)
+    except OSError as exc:
+        logger.debug("Could not save Yahoo info for %s: %s", yf_symbol, exc)
+
+
+def _yahoo_info(yf_symbol: str) -> dict:
+    with _info_lock:
+        hit = _info_cache.get(yf_symbol)
+    if not hit:
+        hit = _disk_info(yf_symbol)
+        if hit:
+            with _info_lock:
+                _info_cache[yf_symbol] = hit
+    if hit and time.time() - hit[0] < INFO_TTL:
+        return hit[1]
+    import yfinance as yf
+
+    try:
+        info = yf.Ticker(yf_symbol).info or {}
+    except Exception as exc:
+        logger.info("Yahoo info %s failed: %s", yf_symbol, exc)
+        info = {}
+    if info:  # never cache a failed lookup; Yahoo throttles in bursts and the next call usually works
+        now = time.time()
+        with _info_lock:
+            _info_cache[yf_symbol] = (now, info)
+        _save_info(yf_symbol, now, info)
+    return info
+
+
+def _yahoo_prices(tickers: list[str], period: str) -> dict[str, pd.Series]:
+    import yfinance as yf
+
+    from ..utils.yf_lock import YF_DOWNLOAD_LOCK
+
+    with YF_DOWNLOAD_LOCK:
+        df = yf.download(tickers, period=period, interval="1d", progress=False, auto_adjust=True, threads=True)
+    if df is None or df.empty:
+        return {}
+    closes = df["Close"] if isinstance(df.columns, pd.MultiIndex) else df[["Close"]].rename(columns={"Close": tickers[0]})
+    return {t: closes[t].dropna() for t in tickers if t in closes and closes[t].notna().sum()}
+
+
+def _naive(s: pd.Series) -> pd.Series:
+    idx = pd.DatetimeIndex(s.index)
+    if idx.tz is not None:
+        idx = idx.tz_localize(None)
+    return pd.Series(s.to_numpy(dtype=float), index=idx.normalize())
+
+
+def _ret(s: pd.Series, days: int) -> Optional[float]:
+    if s.empty or (s.index[-1] - s.index[0]).days < days * 0.97:
+        return None
+    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 _metric_value(info: dict, key: Optional[str], kind: str, label: str) -> Optional[float]:
+    if label == "Analyst target upside":
+        target, price = _f(info.get("targetMeanPrice")), info_price(info)
+        return (target / price - 1) * 100 if target and price else None
+    v = _f(info.get(key)) if key else None
+    if v is None:
+        return None
+    if key in ("grossMargins", "operatingMargins") and v == 0:
+        return None  # Yahoo reports 0 for banks and insurers, where margins do not apply
+    if kind == "pct":
+        return v * 100
+    if key == "debtToEquity":
+        return v / 100  # Yahoo reports D/E in percent
+    return v
+
+
+def compare(items: list[tuple[str, str]], period: str = "1y",
+            info_fetch: InfoFetch = _yahoo_info, price_fetch: PriceFetch = _yahoo_prices) -> dict:
+    """items: [(symbol, market)]. Raises ValueError on bad input."""
+    from .analysis_run import MARKET_INDICES, yahoo_symbol
+
+    items = list(dict.fromkeys((s.strip().upper(), m.strip().lower()) for s, m in items if s.strip()))
+    if not 2 <= len(items) <= MAX_SYMBOLS:
+        raise ValueError(f"Pick between 2 and {MAX_SYMBOLS} symbols")
+    if period not in PERIODS:
+        raise ValueError(f"period must be one of {', '.join(PERIODS)}")
+
+    ticker = {(s, m): yahoo_symbol(s, m) for s, m in items}
+    bench = {m: (MARKET_INDICES.get(m) or MARKET_INDICES["us"])[0] for _, m in items}
+    fetch_period = "5y" if period in ("3y", "5y") else "2y"  # extra history so 1Y/3Y returns resolve
+    with ThreadPoolExecutor(max_workers=6) as pool:
+        infos_f = {k: pool.submit(info_fetch, t) for k, t in ticker.items() if k[1] != "crypto"}
+        prices = price_fetch(list(dict.fromkeys([*ticker.values(), *(b[0] for b in bench.values())])), fetch_period)
+        infos = {k: f.result() for k, f in infos_f.items()}
+
+    out_items, series, warnings = [], {}, []
+    for key in items:
+        s, m = key
+        info = infos.get(key, {})
+        raw = prices.get(ticker[key])
+        if raw is None or len(raw) < 20:
+            warnings.append(f"{s}: no price history, left out of the chart and risk numbers.")
+        else:
+            series[key] = _naive(raw)
+        out_items.append({
+            "symbol": s, "market": m, "yahoo": ticker[key],
+            "name": info.get("shortName") or info.get("longName") or s,
+            "currency": info.get("currency") or ("USD" if m == "crypto" else None),
+            "sector": info.get("sector"), "industry": info.get("industry"),
+            "price": info_price(info) or (float(series[key].iloc[-1]) if key in series else None),
+        })
+    currencies = {i["currency"] for i in out_items if i["currency"]}
+    if len(currencies) > 1:
+        warnings.append("Different currencies: returns are compared in each stock's own currency.")
+
+    start = pd.Timestamp.today().normalize() - pd.Timedelta(days=PERIODS[period])
+    chart: dict[str, dict[str, float]] = {}
+    risk, daily = {}, {}
+    for key, s in series.items():
+        label = key[0]
+        win = s[s.index >= start]
+        if len(win) < 2:
+            continue
+        for d, v in (win / win.iloc[0] * 100).items():
+            chart.setdefault(str(d.date()), {})[label] = round(float(v), 3)
+        r = win.pct_change().dropna()
+        daily[label] = r
+        curve = (1 + r).cumprod()
+        b = prices.get(bench[key[1]][0])
+        beta = None
+        if b is not None and len(r) > 30:
+            br = _naive(b).pct_change().dropna()
+            j = pd.concat([r, br], axis=1, join="inner").dropna()
+            if len(j) > 30 and j.iloc[:, 1].var() > 0:
+                beta = float(j.iloc[:, 0].cov(j.iloc[:, 1]) / j.iloc[:, 1].var())
+        days_per_year = 365 if key[1] == "crypto" else 252
+        vol = float(r.std() * math.sqrt(days_per_year))
+        years = max((win.index[-1] - win.index[0]).days / 365.25, 1e-9)
+        cagr = float((win.iloc[-1] / win.iloc[0]) ** (1 / years) - 1)
+        risk[label] = {
+            "volatility": vol * 100,
+            "max_drawdown": float((curve / curve.cummax() - 1).min()) * 100,
+            "beta": beta, "benchmark": bench[key[1]][1],
+            "return_period": float(win.iloc[-1] / win.iloc[0] - 1) * 100,
+            "sharpe_like": cagr / vol if vol else None,
+        }
+
+    returns = [{"window": w, "values": {k[0]: _ret(s, d) for k, s in series.items()}} for w, d in RETURN_WINDOWS]
+    returns = [r for r in returns if any(v is not None for v in r["values"].values())]
+
+    corr = None
+    if len(daily) >= 2:
+        c = pd.DataFrame(daily).dropna().corr()
+        corr = {"symbols": list(c.columns), "matrix": [[_f(v) for v in row] for row in c.to_numpy()]}
+
+    metrics = []
+    for label, key, kind, higher, group in METRICS:
+        vals = {i["symbol"]: _metric_value(infos.get((i["symbol"], i["market"]), {}), key, kind, label) for i in out_items}
+        if all(v is None for v in vals.values()):
+            continue
+        best = None
+        ranked = {k: v for k, v in vals.items() if v is not None and not (label.startswith("P/") and v <= 0)}
+        if kind == "money" and len(currencies) > 1:
+            ranked = {}  # amounts in different currencies are not comparable
+        if higher is not None and len(ranked) >= 2:
+            best = (max if higher else min)(ranked, key=ranked.get)
+        metrics.append({"label": label, "kind": "pct" if kind == "pct_raw" else kind, "group": group,
+                        "values": vals, "best": best, "higher_better": higher})
+
+    return {
+        "period": period,
+        "items": out_items,
+        "chart": [{"time": d, **v} for d, v in sorted(chart.items())],
+        "returns": returns,
+        "risk": risk,
+        "correlation": corr,
+        "metrics": metrics,
+        "warnings": warnings,
+    }
+
+
+def peers(symbol: str, market: str, limit: int = 6, info_fetch: InfoFetch = _yahoo_info,
+          rows: Optional[list[dict]] = None) -> dict:
+    """Same-market stocks in the same sector, nearest in market cap, preferring Yahoo's same industry."""
+    from .analysis_run import yahoo_symbol
+
+    symbol, market = symbol.upper(), market.lower()
+    if rows is None:
+        from ..data.listings import get_store
+
+        rows = get_store().rows(market)
+    stocks = [r for r in rows if r.get("type") == "stock" and r.get("market_cap")]
+    me = next((r for r in stocks if r["symbol"].upper() == symbol), None)
+    my_info = info_fetch(yahoo_symbol(symbol, market))
+    industry, sector = my_info.get("industry"), my_info.get("sector")
+    cap = (me or {}).get("market_cap") or _f(my_info.get("marketCap"))
+    group_key = "category" if me and me.get("category") else "sector"
+    group_val = (me or {}).get(group_key)
+    if not cap or not group_val:
+        return {"symbol": symbol, "market": market, "peers": [], "basis": None,
+                "note": "Not enough sector or size data to find peers."}
+
+    pool_rows = [r for r in stocks if r.get(group_key) == group_val and r["symbol"].upper() != symbol]
+    pool_rows.sort(key=lambda r: abs(math.log(r["market_cap"] / cap)))
+    candidates = pool_rows[:24]
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        infos = list(pool.map(lambda r: info_fetch(yahoo_symbol(r["symbol"], market)), candidates))
+    same_ind = [(r, i) for r, i in zip(candidates, infos) if industry and i.get("industry") == industry]
+    if len(same_ind) >= 3:
+        chosen, basis = same_ind[:limit], f"Same industry: {industry}"
+    else:
+        same_sec = [(r, i) for r, i in zip(candidates, infos) if sector and i.get("sector") == sector]
+        chosen = (same_ind + [x for x in same_sec if x not in same_ind])[:limit] or list(zip(candidates, infos))[:limit]
+        basis = f"Same sector: {sector or group_val}, closest in size"
+    return {
+        "symbol": symbol, "market": market, "industry": industry, "sector": sector, "basis": basis,
+        "peers": [{"symbol": r["symbol"], "name": r.get("name"), "market_cap": r["market_cap"],
+                   "industry": i.get("industry"), "price": r.get("price"),
+                   "change_percent": r.get("change_percent"),
+                   "pe": _f(i.get("trailingPE")), "currency": r.get("currency")} for r, i in chosen],
+    }