marketmyna 0.2.0__py3-none-any.whl

marketmyna/services/estimates.py

@@ -0,0 +1,109 @@
+"""Analyst estimates and how they are moving (OpenBB equity.estimates).
+
+From Yahoo: consensus EPS and revenue for the current / next quarter and year,
+the EPS consensus 7-90 days ago (so you see revisions), the count of analysts
+revising up vs down, and the last four quarters of actual vs estimated EPS.
+Rising estimates often lead a stock; repeated beats show a company that guides
+conservatively.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Optional
+
+import pandas as pd
+
+from ..core.numbers import finite as _f
+
+PERIOD_LABELS = {"0q": "Current quarter", "+1q": "Next quarter", "0y": "Current year", "+1y": "Next year"}
+TABLES = ("earnings_estimate", "revenue_estimate", "eps_trend", "eps_revisions", "earnings_history")
+
+TickerFetch = Callable[[str], dict]
+
+
+def _yahoo(yf_symbol: str) -> dict:
+    import yfinance as yf
+
+    t = yf.Ticker(yf_symbol)
+    out = {}
+    for name in TABLES:
+        try:
+            df = getattr(t, name)
+            out[name] = df if isinstance(df, pd.DataFrame) else None
+        except Exception:
+            out[name] = None
+    try:
+        info = t.info or {}
+        out["currency"] = info.get("financialCurrency") or info.get("currency")
+    except Exception:
+        out["currency"] = None
+    return out
+
+
+def _row(df: Optional[pd.DataFrame], period: str) -> dict:
+    if df is None or df.empty or period not in df.index:
+        return {}
+    return {k: _f(v) for k, v in df.loc[period].items()}
+
+
+def _chg(now: Optional[float], then: Optional[float]) -> Optional[float]:
+    return (now / then - 1) * 100 if now is not None and then not in (None, 0) else None
+
+
+def build(yf_symbol: str, fetch: TickerFetch = _yahoo) -> dict:
+    raw = fetch(yf_symbol)
+    eps_df, rev_df = raw.get("earnings_estimate"), raw.get("revenue_estimate")
+    trend_df, rev_cnt_df = raw.get("eps_trend"), raw.get("eps_revisions")
+
+    periods = []
+    for key, label in PERIOD_LABELS.items():
+        e, r, tr, rv = _row(eps_df, key), _row(rev_df, key), _row(trend_df, key), _row(rev_cnt_df, key)
+        if not (e or r):
+            continue
+        cur = tr.get("current", e.get("avg"))
+        periods.append({
+            "key": key, "label": label,
+            "eps": {"avg": e.get("avg"), "low": e.get("low"), "high": e.get("high"),
+                    "year_ago": e.get("yearAgoEps"), "growth": _pct(e.get("growth")),
+                    "analysts": e.get("numberOfAnalysts")},
+            "revenue": {"avg": r.get("avg"), "low": r.get("low"), "high": r.get("high"),
+                        "year_ago": r.get("yearAgoRevenue"), "growth": _pct(r.get("growth")),
+                        "analysts": r.get("numberOfAnalysts")},
+            "trend": {"current": cur, "d7": tr.get("7daysAgo"), "d30": tr.get("30daysAgo"),
+                      "d60": tr.get("60daysAgo"), "d90": tr.get("90daysAgo"),
+                      "change_30d": _chg(cur, tr.get("30daysAgo")), "change_90d": _chg(cur, tr.get("90daysAgo"))},
+            "revisions": {"up_7d": rv.get("upLast7days"), "up_30d": rv.get("upLast30days"),
+                          "down_7d": rv.get("downLast7Days"), "down_30d": rv.get("downLast30days")},
+        })
+
+    history = []
+    hist_df = raw.get("earnings_history")
+    if hist_df is not None and not hist_df.empty:
+        for q, row in hist_df.iterrows():
+            actual, est = _f(row.get("epsActual")), _f(row.get("epsEstimate"))
+            if actual is None and est is None:
+                continue
+            history.append({"quarter": str(pd.Timestamp(q).date()) if not isinstance(q, str) else q,
+                             "actual": actual, "estimate": est,
+                             "surprise": _pct(_f(row.get("surprisePercent")))})
+
+    # Revision momentum on the yearly EPS consensus over 90 days
+    yearly = [p["trend"]["change_90d"] for p in periods if p["key"] in ("0y", "+1y") and p["trend"]["change_90d"] is not None]
+    momentum = None
+    if yearly:
+        avg = sum(yearly) / len(yearly)
+        momentum = {"change_90d": avg,
+                    "label": "rising" if avg >= 1 else "falling" if avg <= -1 else "steady"}
+    beats = [h for h in history if h["surprise"] is not None]
+    return {
+        "currency": raw.get("currency"),
+        "periods": periods,
+        "history": history,
+        "momentum": momentum,
+        "beats": {"beat": sum(1 for h in beats if h["surprise"] > 0), "total": len(beats)} if beats else None,
+        "available": bool(periods or history),
+    }
+
+
+def _pct(v: Optional[float]) -> Optional[float]:
+    return v * 100 if v is not None else None

marketmyna/services/etf.py

@@ -0,0 +1,236 @@
+"""ETF look-through: what a fund holds, its sector mix, and overlap between two
+funds (OpenBB etf.holdings / etf.sectors / etf.info).
+
+- US and other Yahoo-covered ETFs: Yahoo fund data (top 10 holdings, sector
+  weights, asset classes, expense ratio, category).
+- Indian index ETFs: Yahoo has no fund data, so the tracked Nifty index is
+  inferred from the ETF's name and its full constituent list is read from
+  niftyindices.com. Weights are estimated from market cap (the real index is
+  free-float weighted, so promoter-heavy names come out overweight).
+- Gold, silver, liquid and G-sec ETFs hold no stocks and say so.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import logging
+import re
+import threading
+import time
+from typing import Callable, Optional
+
+from marketmyna.core.home import app_home
+
+logger = logging.getLogger(__name__)
+
+NIFTY_CSV = "https://www.niftyindices.com/IndexConstituent/{file}.csv"
+CACHE_SECONDS = 24 * 3600
+TOP_N = 25
+
+# (pattern on lower-cased ETF name, index file, index name); first match wins, specific before general
+NIFTY_INDICES = [
+    (r"private bank", "ind_nifty_privatebanklist", "Nifty Private Bank"),
+    (r"psu bank", "ind_niftypsubanklist", "Nifty PSU Bank"),
+    (r"nifty bank|bank (?:nifty|bees|etf)\b", "ind_niftybanklist", "Nifty Bank"),
+    (r"nifty it\b", "ind_niftyitlist", "Nifty IT"),
+    (r"pharma", "ind_niftypharmalist", "Nifty Pharma"),
+    (r"healthcare", "ind_niftyhealthcarelist", "Nifty Healthcare"),
+    (r"fmcg", "ind_niftyfmcglist", "Nifty FMCG"),
+    (r"nifty auto", "ind_niftyautolist", "Nifty Auto"),
+    (r"nifty metal", "ind_niftymetallist", "Nifty Metal"),
+    (r"realty", "ind_niftyrealtylist", "Nifty Realty"),
+    (r"nifty energy", "ind_niftyenergylist", "Nifty Energy"),
+    (r"nifty infra", "ind_niftyinfralist", "Nifty Infrastructure"),
+    (r"cpse", "ind_niftycpselist", "Nifty CPSE"),
+    (r"nifty pse\b", "ind_niftypselist", "Nifty PSE"),
+    (r"commodities", "ind_niftycommoditieslist", "Nifty Commodities"),
+    (r"largemidcap 250|large ?mid ?cap 250", "ind_niftylargemidcap250list", "Nifty LargeMidcap 250"),
+    (r"total market", "ind_niftytotalmarket_list", "Nifty Total Market"),
+    (r"financial services", "ind_niftyfinancelist", "Nifty Financial Services"),
+    (r"next 50|junior", "ind_niftynext50list", "Nifty Next 50"),
+    (r"midcap 150", "ind_niftymidcap150list", "Nifty Midcap 150"),
+    (r"midcap 100", "ind_niftymidcap100list", "Nifty Midcap 100"),
+    (r"midcap 50", "ind_niftymidcap50list", "Nifty Midcap 50"),
+    (r"smallcap 250", "ind_niftysmallcap250list", "Nifty Smallcap 250"),
+    (r"smallcap 100", "ind_niftysmallcap100list", "Nifty Smallcap 100"),
+    (r"nifty 500", "ind_nifty500list", "Nifty 500"),
+    (r"nifty 200", "ind_nifty200list", "Nifty 200"),
+    (r"nifty 100", "ind_nifty100list", "Nifty 100"),
+    (r"nifty (?:index )?50\b|niftybees|nifty etf", "ind_nifty50list", "Nifty 50"),
+]
+# Factor / strategy / BSE indices we have no constituent list for
+UNSUPPORTED = r"momentum|quality|low vol|alpha|value|equal weight|dividend|bse|sensex|nasdaq|s&p|hang seng|growth sectors"
+NO_STOCKS = r"gold|silver|liquid|overnight|g-sec|gilt|government securities|bond|1d rate|money market|bharat bond|sdl"
+
+SECTOR_LABELS = {
+    "realestate": "Real estate", "consumer_cyclical": "Consumer cyclical", "basic_materials": "Basic materials",
+    "consumer_defensive": "Consumer defensive", "technology": "Technology", "communication_services": "Communication",
+    "financial_services": "Financial services", "utilities": "Utilities", "industrials": "Industrials",
+    "energy": "Energy", "healthcare": "Healthcare",
+}
+
+Fetch = Callable[[str], str]
+_cache: dict[str, tuple[float, object]] = {}
+_lock = threading.Lock()
+
+
+def _http(url: str) -> str:
+    import requests
+
+    r = requests.get(url, headers={"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) Chrome/126"}, timeout=20)
+    r.raise_for_status()
+    return r.text
+
+
+def match_index(name: str) -> tuple[Optional[str], Optional[str], str]:
+    """(file, index name, status) where status is ok | no_stocks | unsupported | unknown."""
+    n = (name or "").lower()
+    if re.search(NO_STOCKS, n):
+        return None, None, "no_stocks"
+    if re.search(UNSUPPORTED, n):
+        return None, None, "unsupported"
+    for pattern, file, label in NIFTY_INDICES:
+        if re.search(pattern, n):
+            return file, label, "ok"
+    return None, None, "unknown"
+
+
+def parse_constituents(text: str) -> list[dict]:
+    rows = list(csv.DictReader(io.StringIO(text.lstrip(""))))
+    out = [{"symbol": r.get("Symbol", "").strip(), "name": r.get("Company Name", "").strip(),
+            "industry": r.get("Industry", "").strip()} for r in rows if r.get("Symbol")]
+    if not out:
+        raise ValueError("no constituents in index file")
+    return out
+
+
+def _constituents(file: str, fetch: Fetch) -> list[dict]:
+    key = f"nifty:{file}"
+    with _lock:
+        hit = _cache.get(key)
+    if hit and time.time() - hit[0] < CACHE_SECONDS:
+        return hit[1]  # type: ignore[return-value]
+    path = app_home() / "etf"
+    path.mkdir(parents=True, exist_ok=True)
+    snap = path / f"{file}.json"
+    try:
+        rows = parse_constituents(fetch(NIFTY_CSV.format(file=file)))
+        snap.write_text(json.dumps(rows), encoding="utf-8")
+    except Exception as exc:
+        logger.warning("Index list %s failed: %s", file, exc)
+        if not snap.exists():
+            raise
+        rows = json.loads(snap.read_text(encoding="utf-8"))
+    with _lock:
+        _cache[key] = (time.time(), rows)
+    return rows
+
+
+def _india(symbol: str, row: Optional[dict], caps: dict[str, float], fetch: Fetch) -> dict:
+    name = (row or {}).get("name") or symbol
+    file, index, status = match_index(name)
+    base = {"symbol": symbol, "market": "india", "name": name, "is_etf": True, "source": "niftyindices.com"}
+    if status == "no_stocks":
+        return {**base, "status": status, "note": "This ETF holds gold, silver, bonds or cash, not stocks."}
+    if status != "ok":
+        return {**base, "status": status,
+                "note": "Holdings are only available for ETFs tracking a standard Nifty index."}
+    cons = _constituents(file, fetch)
+    total = sum(caps.get(c["symbol"], 0) for c in cons)
+    holdings = []
+    for c in cons:
+        w = caps.get(c["symbol"], 0) / total if total else 1 / len(cons)
+        holdings.append({"symbol": c["symbol"], "name": c["name"], "weight": w, "sector": c["industry"]})
+    holdings.sort(key=lambda h: -h["weight"])
+    sectors: dict[str, float] = {}
+    for h in holdings:
+        sectors[h["sector"] or "Other"] = sectors.get(h["sector"] or "Other", 0) + h["weight"]
+    return {**base, "status": "ok", "index": index, "count": len(holdings), "weights": "estimated",
+            "holdings": holdings, "top": holdings[:TOP_N],
+            "sectors": [{"name": k, "weight": v} for k, v in sorted(sectors.items(), key=lambda kv: -kv[1])],
+            "top10_weight": sum(h["weight"] for h in holdings[:10]),
+            "note": f"Tracks the {index}. Weights estimated from market cap; the index itself uses free-float weights."}
+
+
+def _yahoo(yf_symbol: str) -> dict:
+    import yfinance as yf
+
+    fd = yf.Ticker(yf_symbol).funds_data
+    out: dict = {}
+    top = fd.top_holdings
+    out["top"] = [{"symbol": str(sym), "name": str(r.get("Name") or sym), "weight": float(r.get("Holding Percent") or 0)}
+                  for sym, r in top.iterrows()] if top is not None else []
+    out["sectors"] = dict(fd.sector_weightings or {})
+    out["assets"] = dict(fd.asset_classes or {})
+    overview = dict(fd.fund_overview or {})
+    out["category"], out["family"] = overview.get("categoryName"), overview.get("family")
+    ops = fd.fund_operations
+    try:
+        col = ops.columns[0]
+        out["expense_ratio"] = float(ops.loc["Annual Report Expense Ratio", col])
+        out["category_expense_ratio"] = float(ops.loc["Annual Report Expense Ratio", "Category Average"])
+        out["turnover"] = float(ops.loc["Annual Holdings Turnover", col])
+        out["total_assets"] = float(ops.loc["Total Net Assets", col])
+    except Exception:
+        pass
+    try:
+        out["description"] = fd.description
+    except Exception:
+        out["description"] = None
+    return out
+
+
+def lookthrough(symbol: str, market: str, fetch: Fetch = _http, yahoo: Callable[[str], dict] = _yahoo,
+                rows: Optional[list[dict]] = None) -> dict:
+    from .analysis_run import yahoo_symbol
+
+    symbol, market = symbol.upper(), market.lower()
+    if market == "india":
+        if rows is None:
+            from ..data.listings import get_store
+
+            rows = get_store().rows("india")
+        me = next((r for r in rows if r["symbol"].upper() == symbol), None)
+        looks_etf = bool(me and re.search(r"\betf\b|bees\b", f"{me.get('name', '')} {symbol}".lower()))
+        if me is not None and me.get("type") != "etf" and not looks_etf:
+            return {"symbol": symbol, "market": market, "is_etf": False}
+        caps = {r["symbol"]: r["market_cap"] for r in rows if r.get("type") == "stock" and r.get("market_cap")}
+        return _india(symbol, me, caps, fetch)
+
+    try:
+        d = yahoo(yahoo_symbol(symbol, market))
+    except Exception as exc:
+        return {"symbol": symbol, "market": market, "is_etf": False, "note": str(exc)[:200]}
+    if not d.get("top") and not d.get("sectors"):
+        return {"symbol": symbol, "market": market, "is_etf": False}
+    sectors = [{"name": SECTOR_LABELS.get(k, k.replace("_", " ").title()), "weight": float(v)}
+               for k, v in d.get("sectors", {}).items() if v]
+    return {
+        "symbol": symbol, "market": market, "is_etf": True, "status": "ok", "source": "Market data feed",
+        "name": d.get("family"), "category": d.get("category"), "family": d.get("family"),
+        "expense_ratio": d.get("expense_ratio"), "category_expense_ratio": d.get("category_expense_ratio"),
+        "turnover": d.get("turnover"), "total_assets": d.get("total_assets"), "description": d.get("description"),
+        "assets": {k: float(v) for k, v in d.get("assets", {}).items() if v},
+        "top": d["top"], "holdings": d["top"], "count": None, "weights": "reported",
+        "top10_weight": sum(h["weight"] for h in d["top"][:10]),
+        "sectors": sorted(sectors, key=lambda s: -s["weight"]),
+        "note": "Only the top 10 holdings are published.",
+    }
+
+
+def overlap(a: dict, b: dict) -> dict:
+    """Weight overlap = sum over shared holdings of min(weight in A, weight in B)."""
+    wa = {h["symbol"]: h["weight"] for h in a.get("holdings") or []}
+    wb = {h["symbol"]: h["weight"] for h in b.get("holdings") or []}
+    shared = sorted(set(wa) & set(wb), key=lambda s: -min(wa[s], wb[s]))
+    partial = a.get("weights") == "reported" or b.get("weights") == "reported"
+    return {
+        "a": a["symbol"], "b": b["symbol"],
+        "overlap": sum(min(wa[s], wb[s]) for s in shared),
+        "shared_count": len(shared),
+        "shared": [{"symbol": s, "weight_a": wa[s], "weight_b": wb[s]} for s in shared[:15]],
+        "partial": partial,
+        "note": "Based on top-10 holdings only, so the true overlap is likely higher." if partial else None,
+    }

marketmyna/services/etf_rotation.py

@@ -0,0 +1,193 @@
+"""Relative rotation for ETFs - the US / Hong Kong / China A counterpart of
+India's mutual-fund rotation (services/fund_rotation.py). Same RS-Ratio /
+RS-Momentum maths (services/rotation.py) on weekly closes, each ETF against
+its home market:
+
+- us:        S&P 500 (SPY); sector SPDRs, themes, styles & size, countries & assets
+- hong_kong: Hang Seng Index; HK / China index ETFs and HK-listed global ETFs
+- china_a:   Shanghai Composite; broad-index and sector ETFs
+
+Views group the ETFs; every ETF is its own point (no baskets needed - an
+ETF already is one). Cached a few hours.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from typing import Callable, Optional
+
+import pandas as pd
+
+from .rotation import TAIL, WINDOW, _weekly, quadrant, rrg
+
+logger = logging.getLogger(__name__)
+
+CACHE_SECONDS = 4 * 3600
+MIN_WEEKS = 30
+
+UNIVERSES: dict[str, dict] = {
+    "us": {
+        "benchmark": ("SPY", "S&P 500"),
+        "views": {
+            "Sectors": [
+                ("XLK", "Technology"), ("XLF", "Financials"), ("XLV", "Health care"), ("XLY", "Consumer discretionary"),
+                ("XLP", "Consumer staples"), ("XLE", "Energy"), ("XLI", "Industrials"), ("XLB", "Materials"),
+                ("XLU", "Utilities"), ("XLRE", "Real estate"), ("XLC", "Communication services"),
+            ],
+            "Themes": [
+                ("SMH", "Semiconductors"), ("IGV", "Software"), ("CIBR", "Cybersecurity"), ("XBI", "Biotech"),
+                ("ITA", "Aerospace & defense"), ("XHB", "Homebuilders"), ("KRE", "Regional banks"), ("JETS", "Airlines"),
+                ("TAN", "Solar"), ("URA", "Uranium"), ("GDX", "Gold miners"), ("BOTZ", "Robotics & AI"), ("ARKK", "Disruptive innovation"),
+            ],
+            "Styles & size": [
+                ("QQQ", "Nasdaq 100"), ("RSP", "S&P 500 equal weight"), ("MDY", "Mid caps"), ("IWM", "Small caps"),
+                ("IWF", "Large growth"), ("IWD", "Large value"), ("MTUM", "Momentum"), ("QUAL", "Quality"),
+                ("USMV", "Minimum volatility"), ("VYM", "High dividend"),
+            ],
+            "Countries & assets": [
+                ("EFA", "Developed ex-US"), ("EEM", "Emerging markets"), ("EWJ", "Japan"), ("EWG", "Germany"),
+                ("EWU", "United Kingdom"), ("INDA", "India"), ("MCHI", "China"), ("EWT", "Taiwan"), ("EWY", "South Korea"),
+                ("EWZ", "Brazil"), ("GLD", "Gold"), ("TLT", "Long Treasuries"), ("HYG", "High-yield bonds"), ("USO", "Crude oil"),
+            ],
+        },
+    },
+    "hong_kong": {
+        "benchmark": ("^HSI", "Hang Seng Index"),
+        "views": {
+            "Hong Kong & China": [
+                ("2800.HK", "Tracker Fund (Hang Seng)"), ("2828.HK", "Hang Seng China Enterprises"),
+                ("3033.HK", "CSOP Hang Seng TECH"), ("3067.HK", "iShares Hang Seng TECH"),
+                ("3069.HK", "ChinaAMC Hang Seng Biotech"), ("3110.HK", "Global X HS High Dividend"),
+                ("2801.HK", "iShares Core MSCI China"), ("2823.HK", "iShares FTSE China A50"), ("3188.HK", "ChinaAMC CSI 300"),
+            ],
+            "Global": [
+                ("2834.HK", "iShares Nasdaq 100"), ("2836.HK", "iShares Core S&P BSE Sensex India"),
+                ("3010.HK", "iShares Core MSCI Asia ex Japan"), ("2840.HK", "SPDR Gold"),
+            ],
+        },
+    },
+    "china_a": {
+        "benchmark": ("000001.SS", "Shanghai Composite"),
+        "views": {
+            "Broad indices": [
+                ("510300.SS", "CSI 300"), ("510500.SS", "CSI 500 (mid caps)"), ("159915.SZ", "ChiNext (growth)"),
+                ("588000.SS", "STAR 50 (tech)"),
+            ],
+            "Sectors": [
+                ("512800.SS", "Banks"), ("512880.SS", "Brokers"), ("512690.SS", "Liquor (baijiu)"), ("159928.SZ", "Consumer staples"),
+                ("512170.SS", "Healthcare"), ("512010.SS", "Pharma"), ("512480.SS", "Semiconductors"), ("159819.SZ", "Artificial intelligence"),
+                ("515050.SS", "5G & telecom"), ("515030.SS", "New-energy vehicles"), ("515790.SS", "Solar (photovoltaic)"),
+                ("516160.SS", "New energy"), ("512660.SS", "Defense"), ("512400.SS", "Non-ferrous metals"), ("515220.SS", "Coal"),
+                ("512200.SS", "Real estate"), ("518880.SS", "Gold"),
+            ],
+        },
+    },
+}
+
+Fetch = Callable[[list[str]], dict[str, pd.Series]]
+_cache: dict[tuple, tuple[float, dict]] = {}
+_closes_cache: dict[tuple[str, str], tuple[float, dict[str, pd.Series]]] = {}
+_lock = threading.Lock()
+
+
+def _yahoo(tickers: list[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="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()}
+
+
+def app_symbol(ticker: str, market: str) -> str:
+    """Yahoo ticker -> the app's symbol for /analyze links (2800.HK -> 02800)."""
+    if market == "hong_kong":
+        return f"{int(ticker.split('.')[0]):05d}"
+    if market == "china_a":
+        return ticker.split(".")[0]
+    return ticker
+
+
+def views(market: str) -> list[str]:
+    return list(UNIVERSES[market]["views"]) if market in UNIVERSES else []
+
+
+def tickers(market: str, view: Optional[str] = None) -> list[str]:
+    """Benchmark + the view's ETFs (Yahoo tickers), for live prices."""
+    cfg = UNIVERSES[market]
+    members = cfg["views"].get(view or next(iter(cfg["views"])), [])
+    return [cfg["benchmark"][0]] + [t for t, _ in members]
+
+
+def build(market: str, view: Optional[str] = None, fetch: Fetch = _yahoo, use_cache: bool = True,
+          live: Optional[dict] = None) -> dict:
+    """`live`: ticker -> {price, day}; today's close moves with it, so the
+    current week's point and quadrant follow the session."""
+    from .live_market import extend_all
+
+    if market not in UNIVERSES:
+        raise ValueError("ETF rotation covers US, Hong Kong and China A")
+    cfg = UNIVERSES[market]
+    view = view or next(iter(cfg["views"]))
+    if view not in cfg["views"]:
+        raise ValueError(f"Unknown view '{view}'")
+    key = (market, view)
+    if use_cache and not live:
+        with _lock:
+            hit = _cache.get(key)
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            return hit[1]
+
+    bench_t, bench_name = cfg["benchmark"]
+    members = cfg["views"][view]
+    closes = None
+    if use_cache:
+        with _lock:
+            hit = _closes_cache.get(key)
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            closes = hit[1]
+    if closes is None:
+        closes = fetch([bench_t] + [t for t, _ in members])
+        if use_cache and closes:
+            with _lock:
+                _closes_cache[key] = (time.time(), closes)
+    if live:
+        closes = extend_all(closes, live)
+    if bench_t not in closes:
+        raise ValueError(f"Benchmark {bench_name} unavailable")
+    bench = _weekly(closes[bench_t])
+
+    items = []
+    for ticker, name in members:
+        s = closes.get(ticker)
+        if s is None:
+            continue
+        w = _weekly(s)
+        if len(w) < MIN_WEEKS:
+            continue
+        path = rrg(w, bench)
+        if path.empty:
+            continue
+        tail = path.tail(TAIL)
+        last = tail.iloc[-1]
+        items.append({
+            "name": name, "code": ticker, "symbol": app_symbol(ticker, market), "category": view,
+            "ratio": float(last["ratio"]), "momentum": float(last["momentum"]),
+            "quadrant": quadrant(float(last["ratio"]), float(last["momentum"])),
+            "return_4w": float(w.iloc[-1] / w.iloc[-5] - 1) * 100 if len(w) > 5 else None,
+            "tail": [{"week": str(i.date()), "ratio": float(v["ratio"]), "momentum": float(v["momentum"])}
+                     for i, v in tail.iterrows()],
+        })
+    order = {"leading": 0, "improving": 1, "weakening": 2, "lagging": 3}
+    items.sort(key=lambda s: (order[s["quadrant"]], -s["ratio"]))
+    out = {"by": "view", "group": view, "market": market,
+           "benchmark": {"symbol": bench_t, "name": bench_name},
+           "as_of": str(bench.index[-1].date()), "window_weeks": WINDOW, "items": items, "groups": views(market)}
+    if use_cache and items and not live:
+        with _lock:
+            _cache[key] = (time.time(), out)
+    return out