marketmyna 0.2.0__py3-none-any.whl

marketmyna/services/crypto_screens.py

@@ -0,0 +1,226 @@
+"""Ready-made crypto screens. Coins have no earnings or book value, so these
+work on price and volume: momentum, strength against Bitcoin, oversold RSI,
+breakouts, drawdowns, and liquidity.
+
+Universe: the 100 most-traded USD pairs in our crypto listing (stablecoins
+dropped), six months of daily closes from Binance's public klines (Yahoo for the
+few coins Binance lacks; Yahoo alone misses many, e.g. SUI, UNI, PEPE).
+Cached CACHE_SECONDS. Same result shape as marketmyna/services/screens.py so the Screens
+card renders both.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import threading
+import time
+from typing import Callable, Optional
+
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+UNIVERSE = 100
+CACHE_SECONDS = 3600
+STABLES = {"USDT", "USDC", "DAI", "FDUSD", "TUSD", "USDE", "PYUSD", "BUSD", "USDD", "USDP", "GUSD", "EURC", "USD1", "RLUSD",
+           "PAXG", "XAUT", "EUR", "EURI", "AEUR"}  # stablecoins and gold tokens: no crypto price action to screen
+
+LABELS = {
+    "volume": "24h volume $", "ret_7d": "7d %", "ret_30d": "30d %", "ret_90d": "90d %", "vs_btc_30d": "vs BTC 30d pts",
+    "rsi14": "RSI 14", "from_high_90d": "From 90d high %", "volatility": "Volatility %/yr", "above_ma50": "Above 50d avg %",
+}
+
+# key: title, description, [(field, op, value)], (sort field, descending), columns
+PRESETS = {
+    "volume_leaders": ("Most traded", "The most liquid coins by 24-hour dollar volume",
+                       [], ("volume", True), ["volume", "ret_7d", "ret_30d", "volatility"]),
+    "momentum": ("Strong momentum", "Up over 10% in 30 days and trading above the 50-day average",
+                 [("ret_30d", ">", 10), ("above_ma50", ">", 0)], ("ret_30d", True),
+                 ["ret_30d", "ret_7d", "above_ma50", "rsi14", "volume"]),
+    "beating_btc": ("Beating Bitcoin", "30-day return ahead of Bitcoin's",
+                    [("vs_btc_30d", ">", 0)], ("vs_btc_30d", True), ["vs_btc_30d", "ret_30d", "ret_90d", "volume"]),
+    "oversold": ("Oversold (RSI < 35)", "Sold hard recently: 14-day RSI under 35",
+                 [("rsi14", "<", 35)], ("rsi14", False), ["rsi14", "ret_7d", "ret_30d", "from_high_90d", "volume"]),
+    "near_high": ("Near 90-day high", "Within 5% of the 90-day closing high",
+                  [("from_high_90d", ">", -5)], ("from_high_90d", True), ["from_high_90d", "ret_30d", "rsi14", "volume"]),
+    "drawdown": ("Deep drawdown", "More than 40% below the 90-day high",
+                 [("from_high_90d", "<", -40)], ("from_high_90d", False), ["from_high_90d", "ret_90d", "rsi14", "volume"]),
+}
+
+Fetch = Callable[[list[str]], dict[str, pd.Series]]
+
+_cache: dict[str, tuple[float, tuple[list[dict], dict]]] = {}
+_lock = threading.Lock()
+
+
+def _binance_one(symbol: str, days: int = 180) -> Optional[pd.Series]:
+    import requests
+
+    pair = symbol.split("-")[0] + "USDT"
+    r = requests.get("https://api.binance.com/api/v3/klines",
+                     params={"symbol": pair, "interval": "1d", "limit": days}, timeout=15)
+    if r.status_code != 200:
+        return None
+    rows = r.json()
+    if not rows:
+        return None
+    return pd.Series([float(k[4]) for k in rows], index=pd.to_datetime([k[0] for k in rows], unit="ms"))
+
+
+def _fetch(tickers: list[str], days: int = 180) -> dict[str, pd.Series]:
+    """Binance first (parallel), Yahoo for the rest."""
+    from concurrent.futures import ThreadPoolExecutor
+
+    def one(t):
+        try:
+            return t, _binance_one(t, days)
+        except Exception:
+            return t, None
+
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        got = {t: s for t, s in pool.map(one, tickers) if s is not None and len(s) > 20}
+    missing = [t for t in tickers if t not in got]
+    if missing:
+        try:
+            got.update(_yahoo(missing))
+        except Exception as exc:
+            logger.warning("Yahoo crypto history failed: %s", exc)
+    return got
+
+
+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="6mo", 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 universe(rows: list[dict]) -> list[dict]:
+    coins = [
+        r for r in rows
+        if r.get("symbol", "").endswith("-USD") and r["symbol"].split("-")[0] not in STABLES and (r.get("volume") or 0) > 0
+    ]
+    if not any(r["symbol"] == "BTC-USD" for r in coins):
+        coins.append({"symbol": "BTC-USD", "name": "BTC", "volume": 0})
+    return sorted(coins, key=lambda r: -(r.get("volume") or 0))[:UNIVERSE]
+
+
+def _ret(s: pd.Series, days: int) -> Optional[float]:
+    if len(s) <= days:
+        return None
+    return float(s.iloc[-1] / s.iloc[-1 - days] - 1) * 100
+
+
+def rsi(s: pd.Series, n: int = 14) -> Optional[float]:
+    if len(s) <= n:
+        return None
+    d = s.diff().dropna()
+    gain = d.clip(lower=0).ewm(alpha=1 / n, adjust=False).mean().iloc[-1]
+    loss = (-d.clip(upper=0)).ewm(alpha=1 / n, adjust=False).mean().iloc[-1]
+    if loss == 0:
+        return 100.0
+    return float(100 - 100 / (1 + gain / loss))
+
+
+def metrics(s: pd.Series, btc_30d: Optional[float]) -> dict:
+    s = s.dropna()
+    out = {"ret_7d": _ret(s, 7), "ret_30d": _ret(s, 30), "ret_90d": _ret(s, 90), "rsi14": rsi(s)}
+    last90 = s.tail(90)
+    out["from_high_90d"] = float(s.iloc[-1] / last90.max() - 1) * 100 if len(last90) else None
+    ma50 = s.tail(50).mean() if len(s) >= 50 else None
+    out["above_ma50"] = float(s.iloc[-1] / ma50 - 1) * 100 if ma50 else None
+    daily = s.pct_change().dropna().tail(30)
+    out["volatility"] = float(daily.std() * math.sqrt(365) * 100) if len(daily) > 5 else None
+    out["vs_btc_30d"] = out["ret_30d"] - btc_30d if out["ret_30d"] is not None and btc_30d is not None else None
+    return out
+
+
+def _passes(m: dict, rules: list) -> bool:
+    for field, op, value in rules:
+        v = m.get(field)
+        if v is None or (op == ">" and not v > value) or (op == "<" and not v < value):
+            return False
+    return True
+
+
+def _rule_text(rule) -> str:
+    field, op, value = rule
+    return f"{LABELS.get(field, field)} {op} {value:g}"
+
+
+def list_presets() -> list[dict]:
+    return [{"key": k, "title": p[0], "description": p[1], "large_only": False, "rules": [_rule_text(r) for r in p[2]]}
+            for k, p in PRESETS.items()]
+
+
+_history: dict[str, tuple[float, dict[str, pd.Series], set[str]]] = {}
+
+
+def history(coins: list[dict], fetch: Fetch = _fetch, use_cache: bool = True) -> dict[str, pd.Series]:
+    """Six months of daily closes for `coins`, cached CACHE_SECONDS (shared by
+    the screens and the crypto market mood)."""
+    wanted = [c["symbol"] for c in coins]
+    if use_cache:
+        with _lock:
+            hit = _history.get("all")
+        if hit and time.time() - hit[0] < CACHE_SECONDS and set(wanted) <= hit[2]:
+            return hit[1]
+    closes = fetch(wanted)
+    if use_cache and closes:
+        with _lock:
+            _history["all"] = (time.time(), closes, set(wanted))
+    return closes
+
+
+def _measured(rows: Optional[list[dict]], fetch: Fetch, use_cache: bool = False) -> tuple[list[dict], dict]:
+    if rows is None:
+        from ..data.listings import get_store
+
+        rows = get_store().rows("crypto")
+    coins = universe(rows)
+    closes = history(coins, fetch, use_cache)
+    btc_30d = _ret(closes["BTC-USD"], 30) if "BTC-USD" in closes else None
+    return coins, {sym: metrics(s, btc_30d) for sym, s in closes.items() if len(s) > 20}
+
+
+def run(key: str, fetch: Fetch = _fetch, rows: Optional[list[dict]] = None, use_cache: bool = True) -> dict:
+    if key not in PRESETS:
+        raise ValueError(f"Unknown screen '{key}'")
+    title, desc, rules, (sort_field, desc_sort), columns = PRESETS[key]
+    hit = None
+    if use_cache:
+        with _lock:
+            hit = _cache.get("all")
+    if hit and time.time() - hit[0] < CACHE_SECONDS:
+        coins, ms = hit[1]
+    else:
+        coins, ms = _measured(rows, fetch, use_cache)
+        if use_cache and ms:
+            with _lock:
+                _cache["all"] = (time.time(), (coins, ms))
+
+    hits = []
+    for c in coins:
+        m = ms.get(c["symbol"])
+        if m is None:
+            continue
+        m = {**m, "volume": c.get("volume")}
+        if _passes(m, rules):
+            hits.append({"symbol": c["symbol"], "name": c.get("name"), "market": "crypto", "market_cap": None,
+                         "volume": c.get("volume"), "price": c.get("price"), "currency": "USD",
+                         "change_percent": c.get("change_percent"), "sector": None,
+                         **{col: m.get(col) for col in columns}})
+    hits.sort(key=lambda h: (h.get(sort_field) is None, -(h.get(sort_field) or 0) if desc_sort else (h.get(sort_field) or 0)))
+    return {
+        "key": key, "title": title, "description": desc, "market": "crypto",
+        "rules": [_rule_text(r) for r in rules] or ["Ranked by 24h volume"],
+        "columns": [{"key": c, "label": LABELS.get(c, c)} for c in columns],
+        "universe": f"{UNIVERSE} most-traded coins (stablecoins excluded)",
+        "scanned": len(ms),
+        "results": hits[:50],
+    }

marketmyna/services/data_export.py

@@ -0,0 +1,91 @@
+"""Personal data export (GDPR art. 15 / 20, India DPDP Act s. 11): everything
+the app stores about one user, as a single JSON document.
+
+Walks the same tables account deletion does (every table with a ``user_id``
+pointing at users, plus their child tables such as holdings, transactions and
+watchlist items), so a table added later is exported without changes here.
+Credentials are never exported: password and 2FA secrets, session and
+one-time token hashes, encrypted API keys and push-subscription keys are left
+out (see REDACT).
+"""
+
+from __future__ import annotations
+
+import base64
+from datetime import date, datetime
+from decimal import Decimal
+
+from sqlalchemy.orm import Session
+
+from ..core import tenant
+from ..storage import Base
+
+# table -> columns never exported (secrets or security tokens, not personal data
+# a person can use). Tables in SKIP_TABLES are left out entirely.
+REDACT = {
+    "user_api_keys": {"key_ciphertext"},
+    "report_runs": {"token"},
+    "web_push_subscriptions": {"p256dh", "auth"},
+}
+SKIP_TABLES: set[str] = set()
+FORMAT_VERSION = 1
+
+
+def _plain(value):
+    if isinstance(value, (datetime, date)):
+        return value.isoformat()
+    if isinstance(value, Decimal):
+        return float(value)
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        return base64.b64encode(bytes(value)).decode()
+    return value
+
+
+def _rows(session: Session, table, where) -> list[dict]:
+    hidden = REDACT.get(table.name, set())
+    cols = [c for c in table.columns if c.name not in hidden]
+    return [{c.name: _plain(row._mapping[c.name]) for c in cols}
+            for row in session.execute(table.select().where(where))]
+
+
+def export_user(session: Session, user_id: int) -> dict:
+    """{"tables": {table: [rows]}} for one user, credentials removed."""
+    tables: dict[str, list[dict]] = {}
+    with tenant.system_scope():
+        users = Base.metadata.tables["users"]
+        tables["users"] = _rows(session, users, users.c.id == user_id)
+        owned: dict[str, list] = {}
+        for table in Base.metadata.sorted_tables:
+            col = table.columns.get("user_id")
+            if col is None or table.name in SKIP_TABLES or table.name == "users":
+                continue
+            if not any(f.column.table.name == "users" for f in col.foreign_keys):
+                continue
+            rows = _rows(session, table, col == user_id)
+            tables[table.name] = rows
+            if "id" in table.columns:
+                owned[table.name] = [r["id"] for r in rows if r.get("id") is not None]
+        # Child tables: rows that point at something the user owns (holdings,
+        # transactions, watchlist items) but carry no user_id of their own.
+        for table in Base.metadata.sorted_tables:
+            if table.name in tables or table.name in SKIP_TABLES or "user_id" in table.columns:
+                continue
+            for col in table.columns:
+                parent = next((f.column.table.name for f in col.foreign_keys if f.column.table.name in owned), None)
+                if parent and owned[parent]:
+                    tables[table.name] = _rows(session, table, col.in_(owned[parent]))
+                    break
+    return {
+        "format": "marketmyna-personal-data",
+        "version": FORMAT_VERSION,
+        "exported_at": datetime.now().isoformat(timespec="seconds"),
+        "user_id": user_id,
+        "notes": [
+            "Everything MarketMyna stores about your account, one list per table.",
+            "Left out on purpose: your password and 2-factor secrets, login and email-link tokens, "
+            "your saved AI keys and webhook links (stored encrypted) "
+            "and the keys of your browser push subscriptions.",
+            "Market data (prices, fund NAVs, listings) is public data, not personal data, and is not included.",
+        ],
+        "tables": {k: v for k, v in tables.items() if v},
+    }

marketmyna/services/dcf.py

@@ -0,0 +1,220 @@
+"""Discounted cash flow, reverse DCF and the Graham number for one stock.
+
+DCF: free cash flow (operating cash flow minus capital expenditure and
+stock-based compensation, latest annual filing) grows at the chosen rate for
+5 years, fades in a straight line to the terminal rate over the next 5, then
+grows at the terminal rate for ever (Gordon growth). Each year is discounted
+at the chosen rate; net cash (cash, short-term and long-term investments,
+minus debt) is added and the total divided by the share count.
+
+Stock-based compensation is a real cost paid in shares instead of cash, so
+it is taken off; leaving it in flatters companies that pay staff in stock.
+
+Reverse DCF: the growth rate in years 1-5 that makes the model value equal
+today's price, with the same discount and terminal rates. It answers "what
+does the price assume?" rather than "what is it worth?".
+
+Graham number: sqrt(22.5 x EPS x book value per share), Benjamin Graham's
+ceiling for a defensive investor (P/E 15 x P/B 1.5).
+
+The page lets the viewer change growth, discount and terminal rates and
+recomputes the same formula in the browser (frontend/src/lib/dcf.ts).
+Defaults are plain starting points, not forecasts. Banks and insurers get
+no DCF (their cash flow statement mixes in lending), only the Graham number.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import threading
+import time
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+HIGH_YEARS, TOTAL_YEARS = 5, 10
+CACHE_SECONDS = 6 * 3600
+
+# currency -> (discount rate, terminal growth): long-run government yield plus
+# an equity risk premium, terminal growth near long-run nominal GDP growth
+DEFAULTS = {"INR": (0.12, 0.05), "USD": (0.09, 0.025)}
+OTHER = (0.10, 0.03)
+
+_cache: dict[tuple[str, str], tuple[float, dict]] = {}
+_lock = threading.Lock()
+
+
+def model_value(fcf: float, growth: float, discount: float, terminal: float,
+                net_cash: float, shares: float) -> Optional[float]:
+    """Per-share value; None when discount <= terminal (no finite answer)."""
+    if discount <= terminal or shares <= 0:
+        return None
+    pv, cash = 0.0, fcf
+    for year in range(1, TOTAL_YEARS + 1):
+        if year <= HIGH_YEARS:
+            g = growth
+        else:  # straight-line fade from the high-growth rate to the terminal rate
+            g = growth + (terminal - growth) * (year - HIGH_YEARS) / (TOTAL_YEARS - HIGH_YEARS)
+        cash *= 1 + g
+        pv += cash / (1 + discount) ** year
+    tv = cash * (1 + terminal) / (discount - terminal)
+    pv += tv / (1 + discount) ** TOTAL_YEARS
+    return (pv + net_cash) / shares
+
+
+def implied_growth(price: float, fcf: float, discount: float, terminal: float,
+                   net_cash: float, shares: float) -> Optional[float]:
+    """Years 1-5 growth that the price implies (bisection), None if outside -50%..+100%."""
+    lo, hi = -0.5, 1.0
+
+    def gap(g):
+        v = model_value(fcf, g, discount, terminal, net_cash, shares)
+        return None if v is None else v - price
+
+    a, b = gap(lo), gap(hi)
+    if a is None or b is None or a > 0 or b < 0:
+        return None
+    for _ in range(80):
+        mid = (lo + hi) / 2
+        if gap(mid) < 0:
+            lo = mid
+        else:
+            hi = mid
+    return (lo + hi) / 2
+
+
+def graham_number(eps: Optional[float], bvps: Optional[float]) -> Optional[float]:
+    if not eps or not bvps or eps <= 0 or bvps <= 0:
+        return None
+    return math.sqrt(22.5 * eps * bvps)
+
+
+def _cagr(newest: Optional[float], oldest: Optional[float], years: int) -> Optional[float]:
+    if not newest or not oldest or newest <= 0 or oldest <= 0 or years <= 0:
+        return None
+    return (newest / oldest) ** (1 / years) - 1
+
+
+def _row(statement: dict, key: str) -> list[Optional[float]]:
+    return next((r["values"] for r in statement.get("rows", []) if r["key"] == key), [])
+
+
+def _fx(from_ccy: str, to_ccy: str) -> Optional[float]:
+    """Units of to_ccy per from_ccy: Yahoo's pair, else the ECB reference
+    rate (the ECB has no TWD, SAR and a few others)."""
+    from ..data import ecb_fx
+    from ..data.yahoo_price import info_price
+    from .compare import _yahoo_info
+
+    pair = f"{from_ccy}{to_ccy}=X"
+    try:
+        rate = info_price(_yahoo_info(pair))
+        if rate and rate > 0:
+            return float(rate)
+    except Exception as exc:
+        logger.info("Yahoo FX %s for DCF failed: %s", pair, exc)
+    try:
+        s = ecb_fx.series([pair], days=14).get(pair)
+        return float(s.iloc[-1]) if s is not None and len(s) else None
+    except Exception as exc:
+        logger.info("FX %s for DCF failed: %s", pair, exc)
+        return None
+
+
+def build(symbol: str, market: str, *, financials: Optional[dict] = None, info: Optional[dict] = None,
+          use_cache: bool = True) -> dict:
+    from ..data.yahoo_price import info_price
+    from .analysis_run import yahoo_symbol
+    from .compare import _yahoo_info
+
+    if market == "crypto":
+        raise ValueError("A DCF does not apply to crypto")
+    key = (symbol, market)
+    if use_cache and financials is None:
+        with _lock:
+            hit = _cache.get(key)
+        if hit and time.time() - hit[0] < CACHE_SECONDS:
+            return hit[1]
+
+    if info is None:
+        info = _yahoo_info(yahoo_symbol(symbol, market))
+    if financials is None:
+        from .financials import cached_financials
+
+        financials = cached_financials(symbol, market, "annual")
+
+    price = info_price(info)
+    price_ccy = info.get("currency") or financials.get("currency")
+    fin_ccy = financials.get("currency") or info.get("financialCurrency") or price_ccy
+    rate = 1.0
+    if fin_ccy and price_ccy and fin_ccy != price_ccy:
+        rate = _fx(fin_ccy, price_ccy) or 0.0
+    discount, terminal = DEFAULTS.get(price_ccy or "", OTHER)
+
+    out: dict = {
+        "symbol": symbol, "market": market, "name": financials.get("name") or symbol,
+        "currency": price_ccy, "price": price, "periods": financials.get("periods", []),
+        "dcf": None, "graham": None, "note": None,
+        "source": f"Annual figures: {financials.get('source') or 'reported financial statements'}; price: market data feed",
+    }
+
+    # Graham number on Yahoo's trailing EPS and book value per share (same currency as the price
+    # only when the filings are in that currency)
+    if fin_ccy == price_ccy:
+        eps, bvps = info.get("trailingEps"), info.get("bookValue")
+        g = graham_number(eps, bvps)
+        if g:
+            out["graham"] = {"value": round(g, 2), "eps": eps, "book_value_per_share": bvps,
+                             "vs_price_pct": round((price / g - 1) * 100, 1) if price else None}
+
+    if financials.get("financial_sector"):
+        out["note"] = "No DCF for banks and insurers: their cash flow statement mixes lending in with operations."
+    else:
+        ocf, capex = _row(financials["cashflow"], "operating_cf"), _row(financials["cashflow"], "capex")
+        sbc = _row(financials["cashflow"], "sbc")
+        sbc = sbc + [None] * (len(ocf) - len(sbc))
+        # Not reported (many Indian filers): counted as zero.
+        fcf_hist = [o + c - (s or 0.0) if o is not None and c is not None else None for o, c, s in zip(ocf, capex, sbc)]
+        cash = next((v for v in _row(financials["balance"], "cash") if v is not None), 0.0)
+        long_term = next((v for v in _row(financials["balance"], "long_term_investments") if v is not None), 0.0)
+        debt = next((v for v in _row(financials["balance"], "total_debt") if v is not None), 0.0)
+        shares = info.get("sharesOutstanding") or next((v for v in _row(financials["balance"], "shares") if v), None)
+        recent = [v for v in fcf_hist[:3] if v is not None]
+        base = fcf_hist[0] if fcf_hist and fcf_hist[0] and fcf_hist[0] > 0 else None
+        base_label = "latest year"
+        if base is None and recent and sum(recent) / len(recent) > 0:
+            base, base_label = sum(recent) / len(recent), f"{len(recent)}-year average (latest year negative)"
+        # Default growth: revenue growth over the filings shown (steadier than free
+        # cash flow, which swings with capex), else free cash flow growth
+        rev = [v for v in _row(financials["income"], "revenue") if v is not None]
+        growth = _cagr(rev[0], rev[-1], len(rev) - 1) if len(rev) >= 3 else None
+        known = [(i, v) for i, v in enumerate(fcf_hist) if v is not None]
+        if growth is None and len(known) >= 3:
+            growth = _cagr(known[0][1], known[-1][1], known[-1][0] - known[0][0])
+        growth = min(max(growth if growth is not None else 0.06, 0.0), 0.15)
+
+        if base is None or not shares or not price or not rate:
+            out["note"] = ("No DCF: free cash flow has been negative" if base is None
+                           else "No DCF: share count, price or currency conversion unavailable")
+        else:
+            base, net_cash = base * rate, (cash + long_term - debt) * rate
+            value = model_value(base, growth, discount, terminal, net_cash, shares)
+            implied = implied_growth(price, base, discount, terminal, net_cash, shares)
+            out["dcf"] = {
+                "base_fcf": base, "base_label": base_label, "net_cash": net_cash, "shares": shares,
+                "sbc": sbc[0] * rate if sbc and sbc[0] is not None else None,
+                "long_term_investments": long_term * rate,
+                "fcf_history": [v * rate if v is not None else None for v in fcf_hist],
+                "converted_from": fin_ccy if rate != 1.0 else None,
+                "defaults": {"growth": round(growth, 4), "discount": discount, "terminal": terminal,
+                             "high_years": HIGH_YEARS, "total_years": TOTAL_YEARS},
+                "value": round(value, 2) if value is not None else None,
+                "vs_price_pct": round((price / value - 1) * 100, 1) if value and value > 0 else None,
+                "implied_growth": round(implied, 4) if implied is not None else None,
+            }
+
+    if use_cache:
+        with _lock:
+            _cache[key] = (time.time(), out)
+    return out