marketmyna 0.2.0__py3-none-any.whl

marketmyna/services/fund_peers.py

@@ -0,0 +1,247 @@
+"""A mutual fund against its competitors.
+
+Competitors are the other schemes in the same SEBI category ("Flexi Cap
+Fund", "Large Cap Fund"...), same plan (Direct / Regular) and growth option,
+one per fund house - the funds an investor would really choose between.
+
+Each is measured from its own NAV history (mfapi.in, cached 12 hours):
+  returns     1Y, 3Y and 5Y (3Y / 5Y annualised)
+  volatility  annualised, last 3 years of daily NAVs
+  drawdown    worst peak-to-trough fall, last 3 years
+  sharpe      3Y return over a 6.5% risk-free rate, per unit of volatility
+  similarity  correlation of daily returns with the chosen fund (last year):
+              0.95+ means the two move almost as one
+  overlap     shared holdings, when both fund houses' portfolio files are
+              loaded (marketmyna/services/fund_holdings.py)
+The chosen fund also gets its rank and quartile in the category on each.
+Facts from public NAVs; past returns don't predict future ones.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import math
+import re
+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 .sip_days import mf_nav
+
+logger = logging.getLogger(__name__)
+
+NAV_TTL = 12 * 3600
+RISK_FREE = 6.5  # % a year, Indian T-bill ballpark
+MAX_PEERS = 60
+TRADING_DAYS = 252
+_EXCLUDE = re.compile(r"\b(idcw|dividend|bonus|payout|reinvest|segregated|series|fmp|fixed (term|maturity)|interval)\b", re.I)
+
+NavFetch = Callable[[str], Optional[pd.Series]]
+_mem: dict[str, tuple[float, Optional[pd.Series]]] = {}
+_lock = threading.Lock()
+
+
+# ---------------------------------------------------------------- NAV cache
+
+def _cache_dir() -> Path:
+    p = app_home() / "cache" / "nav"
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def nav(code: str, fetch: NavFetch = mf_nav) -> Optional[pd.Series]:
+    """Daily NAVs, oldest first; memory then disk cache, 12 hours."""
+    now = time.time()
+    with _lock:
+        hit = _mem.get(code)
+    if hit and now - hit[0] < NAV_TTL:
+        return hit[1]
+    path = _cache_dir() / f"{code}.json"
+    series: Optional[pd.Series] = None
+    try:
+        if path.exists() and now - path.stat().st_mtime < NAV_TTL:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+            series = pd.Series(raw["nav"], index=pd.to_datetime(raw["date"]), dtype=float)
+    except Exception:
+        series = None
+    if series is None:
+        try:
+            series = fetch(code)
+        except Exception as exc:
+            logger.info("NAV history for %s unavailable: %s", code, exc)
+            series = None
+        if series is not None and len(series):
+            try:
+                path.write_text(json.dumps({"date": [d.strftime("%Y-%m-%d") for d in series.index],
+                                            "nav": [float(v) for v in series.values]}), encoding="utf-8")
+            except OSError:
+                pass
+    with _lock:
+        _mem[code] = (now, series)
+    return series
+
+
+# ---------------------------------------------------------------- metrics
+
+def _ret(s: pd.Series, years: float) -> Optional[float]:
+    if s is None or len(s) < 2:
+        return None
+    end = s.index[-1]
+    start_at = end - pd.DateOffset(days=round(365.25 * years))
+    if s.index[0] > start_at + pd.Timedelta(days=7):
+        return None  # fund not that old
+    base = s[s.index <= start_at]
+    if base.empty or base.iloc[-1] <= 0:
+        return None
+    growth = s.iloc[-1] / base.iloc[-1]
+    return (growth ** (1 / years) - 1) * 100 if years > 1 else (growth - 1) * 100
+
+
+def metrics(s: Optional[pd.Series]) -> dict:
+    out = {"r1": None, "r3": None, "r5": None, "volatility": None, "drawdown": None, "sharpe": None,
+           "since": None, "nav": None}
+    if s is None or len(s) < 30:
+        return out
+    out["nav"] = _f(s.iloc[-1])
+    out["since"] = s.index[0].strftime("%Y-%m-%d")
+    out["r1"], out["r3"], out["r5"] = _ret(s, 1), _ret(s, 3), _ret(s, 5)
+    last3 = s[s.index >= s.index[-1] - pd.DateOffset(years=3)]
+    daily = last3.pct_change().dropna()
+    if len(daily) > 60:
+        vol = float(daily.std() * math.sqrt(TRADING_DAYS) * 100)
+        out["volatility"] = vol
+        peak = last3.cummax()
+        out["drawdown"] = float(((last3 / peak) - 1).min() * 100)
+        basis = out["r3"] if out["r3"] is not None else out["r1"]
+        if basis is not None and vol > 0:
+            out["sharpe"] = (basis - RISK_FREE) / vol
+    return out
+
+
+def similarity(a: Optional[pd.Series], b: Optional[pd.Series]) -> Optional[float]:
+    if a is None or b is None:
+        return None
+    cutoff = a.index[-1] - pd.DateOffset(years=1)
+    ra = a[a.index >= cutoff].pct_change()
+    rb = b[b.index >= cutoff].pct_change()
+    joined = pd.concat([ra, rb], axis=1, join="inner").dropna()
+    if len(joined) < 60:
+        return None
+    return _f(joined.iloc[:, 0].corr(joined.iloc[:, 1]))
+
+
+# ---------------------------------------------------------------- peers
+
+def _growth(row: dict) -> bool:
+    text = f"{row.get('option') or ''} {row.get('name') or ''}"
+    return "growth" in text.lower() and not _EXCLUDE.search(text)
+
+
+def candidates(row: dict, rows: list[dict]) -> list[dict]:
+    """Same SEBI category and plan, growth option, open-ended; one per fund house
+    (the chosen fund always included)."""
+    category, plan = row.get("sector"), row.get("plan")
+    best: dict[str, dict] = {}
+    for r in rows:
+        if r.get("type") != "mf" or r.get("sector") != category or r.get("plan") != plan:
+            continue
+        if str(r["symbol"]) != str(row["symbol"]) and not _growth(r):
+            continue
+        if "close ended" in str(r.get("sector") or "").lower():
+            continue
+        amc = r.get("amc") or r["symbol"]
+        if str(r["symbol"]) == str(row["symbol"]):
+            best[amc] = r
+        elif amc not in best or (len(r["name"]) < len(best[amc]["name"]) and str(best[amc]["symbol"]) != str(row["symbol"])):
+            best[amc] = r  # the plainest name is usually the flagship scheme
+    out = list(best.values())
+    if not any(str(r["symbol"]) == str(row["symbol"]) for r in out):
+        out.append(row)
+    return out
+
+
+def _overlap(a: Optional[dict], b: Optional[dict]) -> Optional[float]:
+    """Share of the portfolio the two funds hold in common (sum of min weights)."""
+    from .fund_holdings import pair_overlap
+
+    out = pair_overlap(a, b)
+    return out["overlap"] if out else None
+
+
+def _rank(values: list[tuple[str, Optional[float]]], code: str, higher_better: bool = True) -> Optional[dict]:
+    scored = [(c, v) for c, v in values if v is not None]
+    mine = next((v for c, v in scored if c == code), None)
+    if mine is None or len(scored) < 3:
+        return None
+    ordered = sorted(scored, key=lambda t: -t[1] if higher_better else t[1])
+    position = next(i for i, (c, _) in enumerate(ordered) if c == code) + 1
+    quartile = min(4, 1 + (position - 1) * 4 // len(ordered))
+    return {"rank": position, "of": len(ordered), "quartile": quartile,
+            "median": sorted(v for _, v in scored)[len(scored) // 2]}
+
+
+def compare(code: str, rows: Optional[list[dict]] = None, fetch: NavFetch = mf_nav,
+            holdings: Optional[Callable[[str], dict]] = None) -> dict:
+    if rows is None:
+        from ..data.listings import get_store
+
+        rows = get_store().rows("india")
+    row = next((r for r in rows if r.get("type") == "mf" and str(r["symbol"]) == str(code)), None)
+    if row is None:
+        return {"status": "unknown", "note": "No such scheme."}
+    peers = candidates(row, rows)
+    if len(peers) > MAX_PEERS:
+        peers = sorted(peers, key=lambda r: str(r["symbol"]) != str(code))[:MAX_PEERS]
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        series = dict(zip((str(p["symbol"]) for p in peers), pool.map(lambda p: nav(str(p["symbol"]), fetch), peers)))
+    mine = series.get(str(code))
+
+    if holdings is None:
+        from . import fund_holdings
+
+        holdings = fund_holdings.for_fund
+    my_holdings = None
+    try:
+        my_holdings = holdings(str(code))
+    except Exception:
+        pass
+
+    out_rows = []
+    for p in peers:
+        c = str(p["symbol"])
+        m = metrics(series.get(c))
+        if m["nav"] is None:
+            continue
+        overlap = None
+        if c != str(code) and my_holdings and my_holdings.get("status") == "ok":
+            try:
+                overlap = _overlap(my_holdings, holdings(c))
+            except Exception:
+                overlap = None
+        out_rows.append({"code": c, "name": p["name"], "amc": p.get("amc"), "is_self": c == str(code),
+                         **m, "similarity": 1.0 if c == str(code) else similarity(mine, series.get(c)),
+                         "overlap": overlap})
+    out_rows.sort(key=lambda r: (r["r3"] is None, -(r["r3"] or 0), -(r["r1"] or 0)))
+
+    ranks = {}
+    for key, higher in (("r1", True), ("r3", True), ("r5", True), ("volatility", False), ("drawdown", True),
+                        ("sharpe", True)):
+        ranks[key] = _rank([(r["code"], r[key]) for r in out_rows], str(code), higher)
+    closest = sorted((r for r in out_rows if not r["is_self"] and r["similarity"] is not None),
+                     key=lambda r: -r["similarity"])[:3]
+    return {
+        "status": "ok", "code": str(code), "name": row["name"],
+        "category": row.get("sector"), "group": row.get("category"), "plan": row.get("plan"),
+        "count": len(out_rows), "ranks": ranks, "rows": out_rows,
+        "closest": [{"code": r["code"], "name": r["name"], "similarity": r["similarity"]} for r in closest],
+        "risk_free": RISK_FREE,
+        "note": "Same SEBI category and plan, growth option, one scheme per fund house. Past returns don't predict future ones.",
+    }

marketmyna/services/fund_rotation.py

@@ -0,0 +1,206 @@
+"""Relative rotation for Indian equity mutual funds: is a category, a fund
+house, or a single fund Leading, Weakening, Lagging or Improving against the
+Nifty 500? Same RS-Ratio / RS-Momentum maths as the stock sector view
+(services/rotation.py), on weekly NAVs.
+
+- Categories (Large Cap, Mid Cap, Small Cap, Flexi Cap, ELSS, ...) and fund
+  houses are equal-weighted baskets of their Direct-Growth equity funds;
+  the longest-running schemes (lowest AMFI codes) are picked first.
+- Drill into one category or fund house to see each of its funds.
+NAVs come from mfapi.in (AMFI data); each fund's history is cached for the
+day, results for a few hours (NAVs change once a day).
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Optional
+
+import pandas as pd
+
+from .rotation import TAIL, WINDOW, _weekly, quadrant, rrg
+
+logger = logging.getLogger(__name__)
+
+BENCHMARK = ("^CRSLDX", "Nifty 500")
+BASKET = 8  # funds per category / fund house basket
+DRILL = 15  # funds shown when drilling into one group
+MIN_WEEKS = 30
+CACHE_SECONDS = 6 * 3600
+EQUITY_CATEGORIES = ("Equity", "ELSS (Tax Saving)")
+# Fund-house baskets lean on the core diversified categories first.
+CORE = ("Large Cap Fund", "Flexi Cap Fund", "Large & Mid Cap Fund", "Mid Cap Fund", "Small Cap Fund",
+        "Multi Cap Fund", "ELSS", "Focused Fund", "Value Fund")
+
+NavFetch = Callable[[int], Optional[pd.Series]]
+_cache: dict[tuple, tuple[float, dict]] = {}
+_navs: dict[int, tuple[float, Optional[pd.Series]]] = {}
+_lock = threading.Lock()
+
+
+def _nav(code: int) -> Optional[pd.Series]:
+    from ..data.mutual_funds import MutualFundDataFetcher
+
+    with _lock:
+        hit = _navs.get(code)
+    if hit and time.time() - hit[0] < CACHE_SECONDS:
+        return hit[1]
+    try:
+        df = MutualFundDataFetcher().get_historical_nav(code, days=400)
+        s = df["nav"].astype(float) if not df.empty else None
+    except Exception as exc:
+        logger.debug("NAV %s failed: %s", code, exc)
+        s = None
+    with _lock:
+        _navs[code] = (time.time(), s)
+    return s
+
+
+def _bench() -> pd.Series:
+    import yfinance as yf
+
+    h = yf.Ticker(BENCHMARK[0]).history(period="1y")
+    if h.empty:
+        raise ValueError(f"{BENCHMARK[1]} is unavailable right now")
+    return _weekly(h["Close"])
+
+
+def equity_funds(rows: list[dict]) -> list[dict]:
+    """Direct-plan, growth-option equity funds (not index funds / ETFs)."""
+    out = []
+    for r in rows:
+        if r.get("type") != "mf" or r.get("category") not in EQUITY_CATEGORIES:
+            continue
+        option = (r.get("option") or "").lower()
+        if r.get("plan") != "Direct" or "growth" not in option or "idcw" in option:
+            continue
+        if not str(r.get("symbol", "")).isdigit():
+            continue
+        out.append(r)
+    # Oldest schemes first; one entry per fund name (a merged scheme can keep
+    # two AMFI codes under the same name).
+    seen, unique = set(), []
+    for r in sorted(out, key=lambda r: int(r["symbol"])):
+        k = (r.get("amc"), _short(r.get("name", "")).lower())
+        if k not in seen:
+            seen.add(k)
+            unique.append(r)
+    return unique
+
+
+def _group_key(r: dict, by: str) -> Optional[str]:
+    if by == "amc":
+        return r.get("amc")
+    sector = r.get("sector") or ""
+    if "ELSS" in sector or r.get("category") == "ELSS (Tax Saving)":
+        return "ELSS"
+    if sector in ("Sectoral/ Thematic", "Thematic Fund", "Sectoral Fund"):
+        return "Sectoral / Thematic"
+    return sector or None
+
+
+def _short(name: str) -> str:
+    for cut in (" - Direct Plan", " Direct Plan", " - Direct", "-Direct", " Direct"):
+        if cut in name:
+            return name.split(cut)[0].strip()
+    return name
+
+
+def _point(weekly: pd.Series, bench: pd.Series) -> Optional[dict]:
+    path = rrg(weekly, bench)
+    if path.empty:
+        return None
+    tail = path.tail(TAIL)
+    last = tail.iloc[-1]
+    return {
+        "ratio": float(last["ratio"]), "momentum": float(last["momentum"]),
+        "quadrant": quadrant(float(last["ratio"]), float(last["momentum"])),
+        "return_4w": float(weekly.iloc[-1] / weekly.iloc[-5] - 1) * 100 if len(weekly) > 5 else None,
+        "tail": [{"week": str(i.date()), "ratio": float(v["ratio"]), "momentum": float(v["momentum"])}
+                 for i, v in tail.iterrows()],
+    }
+
+
+def build(by: str = "category", name: Optional[str] = None, rows: Optional[list[dict]] = None,
+          nav: NavFetch = _nav, bench: Optional[Callable[[], pd.Series]] = None) -> dict:
+    """by: "category" or "amc". With `name`, each fund inside that group."""
+    if by not in ("category", "amc"):
+        raise ValueError("Group by category or amc")
+    key = (by, name)
+    use_cache = rows is None
+    if use_cache:
+        with _lock:
+            hit = _cache.get(key)
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            return hit[1]
+        from ..data.listings import get_store
+
+        rows = get_store().rows("india")
+
+    funds = equity_funds(rows)
+    groups: dict[str, list[dict]] = {}
+    for r in funds:
+        g = _group_key(r, by)
+        if g:
+            groups.setdefault(g, []).append(r)
+
+    if name is not None:
+        if name not in groups:
+            raise ValueError(f"No equity funds found for '{name}'")
+        picked = {name: groups[name][:DRILL]}
+    elif by == "amc":
+        # A fund house: its core diversified funds first, then the rest.
+        picked = {g: sorted(m, key=lambda r: (_group_key(r, "category") not in CORE, int(r["symbol"])))[:BASKET]
+                  for g, m in groups.items() if len(m) >= 3}
+    else:
+        picked = {g: m[:BASKET] for g, m in groups.items() if len(m) >= 3}
+
+    codes = sorted({int(r["symbol"]) for m in picked.values() for r in m})
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        series = dict(zip(codes, pool.map(nav, codes)))
+    weekly = {c: _weekly(s) for c, s in series.items() if s is not None and len(s.dropna()) > MIN_WEEKS * 5}
+    b = (bench or _bench)()
+
+    items = []
+    for g, members in picked.items():
+        if name is not None:  # one point per fund
+            for r in members:
+                w = weekly.get(int(r["symbol"]))
+                if w is None or len(w) < MIN_WEEKS:
+                    continue
+                p = _point(w, b)
+                if p:
+                    items.append({"name": _short(r["name"]), "code": r["symbol"], "amc": r.get("amc"),
+                                  "category": _group_key(r, "category"), **p})
+            continue
+        parts = [weekly[int(r["symbol"])] for r in members if int(r["symbol"]) in weekly
+                 and len(weekly[int(r["symbol"])]) >= MIN_WEEKS]
+        if len(parts) < 2:
+            continue
+        frame = pd.concat([p / p.iloc[0] for p in parts], axis=1).ffill().dropna()
+        basket = frame.mean(axis=1)  # equal weight
+        p = _point(basket, b)
+        if p:
+            items.append({"name": g, "funds": len(parts), "total_funds": len(groups[g]), **p})
+
+    order = {"leading": 0, "improving": 1, "weakening": 2, "lagging": 3}
+    items.sort(key=lambda s: (order[s["quadrant"]], -s["ratio"]))
+    out = {"by": by, "group": name, "benchmark": {"symbol": BENCHMARK[0], "name": BENCHMARK[1]},
+           "as_of": str(b.index[-1].date()), "window_weeks": WINDOW, "items": items,
+           "groups": sorted(groups) if name is None else None}
+    if use_cache:
+        with _lock:
+            _cache[key] = (time.time(), out)
+    return out
+
+
+def warm() -> None:
+    """Pre-build both views after start-up so the first visitor doesn't wait."""
+    for by in ("category", "amc"):
+        try:
+            build(by)
+        except Exception as exc:
+            logger.info("Fund rotation warm-up (%s) skipped: %s", by, exc)

marketmyna/services/fund_style.py

@@ -0,0 +1,179 @@
+"""A fund's investing style from what it actually holds, and whether it
+stays inside its SEBI category's rules.
+
+Style: the fund's P/E and P/B (weight-averaged the harmonic way, which is
+how an index's P/E is built) against the same measures for the 100 largest
+Indian companies. Cheaper on both = Value, dearer = Growth, else Blend.
+Size: from the large / mid / small split of its Indian shares.
+
+Drift: SEBI's categorisation rules (2017, multi cap amended 2020) as a share
+of the whole fund - Large Cap >= 80% large caps, Mid Cap >= 65% mid, Small
+Cap >= 65% small, Large & Mid >= 35% each, Multi Cap >= 25% each of large,
+mid and small, Focused <= 30 stocks, equity categories >= 65% (ELSS 80%) in
+shares. Company sizes here use today's market caps; AMFI's official list uses
+six-month averages, so a fund right at a limit may differ slightly.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Optional
+
+logger = logging.getLogger(__name__)
+
+CACHE_SECONDS = 12 * 3600
+MARKET_N = 100  # "the market" for style = the 100 largest companies (like the Nifty 100)
+VALUE_GROWTH_BAND = 0.15  # average log ratio beyond +-0.15 (~16%) leaves Blend
+
+# category keyword -> list of (rule label, check(split, equity_pct, count) -> bool)
+RULES: list[tuple[str, list[tuple[str, Callable[[dict, float, int], bool]]]]] = [
+    ("large & mid", [("At least 35% in large caps", lambda s, e, n: s["large"] >= 35),
+                     ("At least 35% in mid caps", lambda s, e, n: s["mid"] >= 35)]),
+    ("large cap", [("At least 80% in large caps", lambda s, e, n: s["large"] >= 80)]),
+    ("mid cap", [("At least 65% in mid caps", lambda s, e, n: s["mid"] >= 65)]),
+    ("small cap", [("At least 65% in small caps", lambda s, e, n: s["small"] >= 65)]),
+    ("multi cap", [("At least 75% in shares", lambda s, e, n: e >= 75),
+                   ("At least 25% each in large, mid and small caps",
+                    lambda s, e, n: min(s["large"], s["mid"], s["small"]) >= 25)]),
+    ("focused", [("No more than 30 stocks", lambda s, e, n: n <= 30),
+                 ("At least 65% in shares", lambda s, e, n: e >= 65)]),
+    ("elss", [("At least 80% in shares", lambda s, e, n: e >= 80)]),
+    ("flexi cap", [("At least 65% in shares", lambda s, e, n: e >= 65)]),
+    ("value", [("At least 65% in shares", lambda s, e, n: e >= 65)]),
+    ("contra", [("At least 65% in shares", lambda s, e, n: e >= 65)]),
+    ("dividend yield", [("At least 65% in shares", lambda s, e, n: e >= 65)]),
+]
+
+_cache: dict[str, tuple[float, dict]] = {}
+_market: dict[str, tuple[float, dict]] = {}
+_lock = threading.Lock()
+
+InfoFetch = Callable[[str], dict]
+
+
+def _info(symbol: str) -> dict:
+    from .analysis_run import yahoo_symbol
+    from .compare import _yahoo_info
+
+    return _yahoo_info(yahoo_symbol(symbol, "india")) or {}
+
+
+def _pos(v) -> Optional[float]:
+    try:
+        f = float(v)
+    except (TypeError, ValueError):
+        return None
+    return f if math.isfinite(f) and f > 0 else None
+
+
+def weighted_ratios(items: list[tuple[float, dict]]) -> dict:
+    """items: (weight, yahoo info). Harmonic weight-average for P/E and P/B (a
+    loss-maker's P/E is skipped), plain weight-average for ROE; with coverage."""
+    out: dict = {}
+    total = sum(w for w, _ in items) or 1.0
+    for key, field in (("pe", "trailingPE"), ("pb", "priceToBook")):
+        pairs = [(w, _pos(i.get(field))) for w, i in items]
+        pairs = [(w, v) for w, v in pairs if v]
+        cover = sum(w for w, _ in pairs)
+        out[key] = cover / sum(w / v for w, v in pairs) if pairs else None
+        out[f"{key}_coverage"] = cover / total * 100
+    roe = [(w, i.get("returnOnEquity")) for w, i in items if isinstance(i.get("returnOnEquity"), (int, float))]
+    cw = sum(w for w, _ in roe)
+    out["roe"] = sum(w * v for w, v in roe) / cw * 100 if cw else None
+    return out
+
+
+def market_ratios(fetch: InfoFetch = _info, rows: Optional[list[dict]] = None) -> dict:
+    """Cap-weighted P/E and P/B of the 100 largest Indian companies, cached."""
+    with _lock:
+        hit = _market.get("india")
+    if rows is None and hit and time.time() - hit[0] < CACHE_SECONDS:
+        return hit[1]
+    if rows is None:
+        from ..data.listings import get_store
+
+        rows = get_store().rows("india")
+    top = sorted((r for r in rows if r.get("type") == "stock" and r.get("market_cap")),
+                 key=lambda r: -r["market_cap"])[:MARKET_N]
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        infos = list(pool.map(lambda r: fetch(r["symbol"]), top))
+    out = weighted_ratios([(r["market_cap"], i or {}) for r, i in zip(top, infos)])
+    with _lock:
+        _market["india"] = (time.time(), out)
+    return out
+
+
+def style_label(fund: dict, market: dict) -> Optional[dict]:
+    logs = [math.log(fund[k] / market[k]) for k in ("pe", "pb") if fund.get(k) and market.get(k)]
+    if not logs:
+        return None
+    score = sum(logs) / len(logs)
+    label = "Value" if score < -VALUE_GROWTH_BAND else "Growth" if score > VALUE_GROWTH_BAND else "Blend"
+    return {"label": label, "score": score}
+
+
+def size_label(split: dict) -> Optional[str]:
+    domestic = split["large"] + split["mid"] + split["small"]
+    if domestic <= 0:
+        return None
+    large, mid, small = (split[k] / domestic * 100 for k in ("large", "mid", "small"))
+    if large >= 70:
+        return "Large"
+    if small >= 35:
+        return "Small"
+    if mid >= 35:
+        return "Mid"
+    return "Multi"
+
+
+def rule_checks(category: Optional[str], split: dict, equity_pct: float, count: int) -> list[dict]:
+    cat = (category or "").lower()
+    for key, rules in RULES:
+        if key in cat:
+            return [{"rule": label, "ok": bool(check(split, equity_pct, count))} for label, check in rules]
+    return []
+
+
+def build(code: str, holdings: Optional[dict] = None, fetch: InfoFetch = _info,
+          market: Optional[dict] = None, category: Optional[str] = None, use_cache: bool = True) -> dict:
+    code = str(code)
+    if use_cache and holdings is None:
+        with _lock:
+            hit = _cache.get(code)
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            return hit[1]
+    if holdings is None:
+        from . import fund_holdings
+
+        holdings = fund_holdings.for_fund(code)
+    if holdings.get("status") != "ok":
+        return {"status": "missing", "note": holdings.get("note") or "Holdings are not available for this fund yet."}
+    if category is None:
+        from ..data.listings import get_store
+
+        row = next((r for r in get_store().rows("india") if r.get("type") == "mf" and str(r["symbol"]) == code), {})
+        category = row.get("sector")
+    split = {"large": 0.0, "mid": 0.0, "small": 0.0, "foreign": 0.0, "other": 0.0}
+    for c in holdings.get("cap_split") or []:
+        split[c["kind"]] = c["weight"]
+    stocks = [h for h in holdings.get("holdings", []) if h.get("kind") in ("equity", "foreign_equity") and h.get("weight")]
+    equity_pct = sum(h["weight"] for h in stocks)
+    indian = [h for h in stocks if h.get("symbol")]
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        infos = list(pool.map(lambda h: fetch(h["symbol"]), indian))
+    ratios = weighted_ratios([(h["weight"], i or {}) for h, i in zip(indian, infos)])
+    mkt = market if market is not None else market_ratios(fetch)
+    out = {"status": "ok", "category": category, "size": size_label(split), "style": style_label(ratios, mkt),
+           "fund": ratios, "market": mkt, "equity_pct": equity_pct, "split": split, "count": len(stocks),
+           "checks": rule_checks(category, split, equity_pct, len(stocks)), "as_of": holdings.get("as_of"),
+           "note": "Valuations from the market data feed for the fund's Indian holdings; 'market' = the 100 largest "
+                   "Indian companies. Company sizes use today's market caps (AMFI's official list uses "
+                   "six-month averages)."}
+    if use_cache:
+        with _lock:
+            _cache[code] = (time.time(), out)
+    return out