marketmyna 0.2.0__py3-none-any.whl

marketmyna/trading/indicators.py

@@ -0,0 +1,303 @@
+"""Trader indicators on OHLCV frames (lower-case columns). Pure pandas, one
+implementation shared by the chart, the alert engine, the scanner and tests.
+
+Formulas for the oscillators, channels, Ichimoku, candlestick patterns and
+divergences follow the OpenBB technical extension (Apache 2.0,
+https://github.com/OpenBB-finance/OpenBB), reimplemented here without pandas-ta."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+
+def ema(series: pd.Series, period: int) -> pd.Series:
+    return series.ewm(span=period, adjust=False).mean()
+
+
+def rsi(close: pd.Series, period: int = 14) -> pd.Series:
+    """Wilder's RSI."""
+    delta = close.diff()
+    gain = delta.clip(lower=0).ewm(alpha=1 / period, adjust=False, min_periods=period).mean()
+    loss = (-delta.clip(upper=0)).ewm(alpha=1 / period, adjust=False, min_periods=period).mean()
+    rs = gain / loss
+    out = 100 - 100 / (1 + rs)
+    return out.where(loss != 0, 100.0).where(gain.notna())
+
+
+def atr(df: pd.DataFrame, period: int = 14) -> pd.Series:
+    prev_close = df["close"].shift(1)
+    tr = pd.concat(
+        [df["high"] - df["low"], (df["high"] - prev_close).abs(), (df["low"] - prev_close).abs()], axis=1
+    ).max(axis=1)
+    return tr.ewm(alpha=1 / period, adjust=False, min_periods=period).mean()
+
+
+def session_key(index: pd.Index) -> pd.Index:
+    """Trading day of each bar, in the bars' own (exchange) timezone."""
+    return pd.Index(pd.DatetimeIndex(index).date)
+
+
+def vwap(df: pd.DataFrame) -> pd.Series:
+    """Volume-weighted average price, restarting every session."""
+    typical = (df["high"] + df["low"] + df["close"]) / 3
+    volume = df["volume"].fillna(0)
+    day = session_key(df.index)
+    pv = (typical * volume).groupby(day).cumsum()
+    vol = volume.groupby(day).cumsum()
+    return (pv / vol.where(vol > 0)).set_axis(df.index)
+
+
+def supertrend(df: pd.DataFrame, period: int = 10, multiplier: float = 3.0) -> tuple[pd.Series, pd.Series]:
+    """(line, direction): direction 1 = uptrend (line below price), -1 = down."""
+    mid = (df["high"] + df["low"]) / 2
+    band = multiplier * atr(df, period)
+    upper, lower = (mid + band).to_numpy(), (mid - band).to_numpy()
+    close = df["close"].to_numpy()
+    n = len(df)
+    line = [float("nan")] * n
+    direction = [0] * n
+    final_upper, final_lower = upper.copy(), lower.copy()
+    for i in range(n):
+        if i == 0 or pd.isna(upper[i]) or pd.isna(final_upper[i - 1]):
+            direction[i] = 1
+            continue
+        final_upper[i] = upper[i] if upper[i] < final_upper[i - 1] or close[i - 1] > final_upper[i - 1] else final_upper[i - 1]
+        final_lower[i] = lower[i] if lower[i] > final_lower[i - 1] or close[i - 1] < final_lower[i - 1] else final_lower[i - 1]
+        if direction[i - 1] == -1 and close[i] > final_upper[i - 1]:
+            direction[i] = 1
+        elif direction[i - 1] == 1 and close[i] < final_lower[i - 1]:
+            direction[i] = -1
+        else:
+            direction[i] = direction[i - 1] or 1
+        line[i] = final_lower[i] if direction[i] == 1 else final_upper[i]
+    return pd.Series(line, index=df.index), pd.Series(direction, index=df.index)
+
+
+def pivots(high: float, low: float, close: float) -> dict[str, float]:
+    """Classic floor pivots from the previous session's high / low / close."""
+    p = (high + low + close) / 3
+    return {
+        "R3": high + 2 * (p - low),
+        "R2": p + (high - low),
+        "R1": 2 * p - low,
+        "P": p,
+        "S1": 2 * p - high,
+        "S2": p - (high - low),
+        "S3": low - 2 * (high - p),
+    }
+
+
+def opening_range(df: pd.DataFrame, minutes: int = 15) -> dict[str, float] | None:
+    """High / low of the first `minutes` of the latest session (intraday bars)."""
+    if df.empty:
+        return None
+    index = pd.DatetimeIndex(df.index)
+    last_day = index[-1].date()
+    today = df[index.date == last_day]
+    start = pd.DatetimeIndex(today.index)[0]
+    first = today[pd.DatetimeIndex(today.index) < start + pd.Timedelta(minutes=minutes)]
+    if first.empty:
+        return None
+    return {"high": float(first["high"].max()), "low": float(first["low"].min())}
+
+
+# ------------------------------------------------------------------ trend / channels
+
+
+def sma(series: pd.Series, period: int) -> pd.Series:
+    return series.rolling(period, min_periods=period).mean()
+
+
+def macd(close: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9) -> pd.DataFrame:
+    """Columns: macd, signal, hist."""
+    line = ema(close, fast) - ema(close, slow)
+    sig = ema(line, signal)
+    return pd.DataFrame({"macd": line, "signal": sig, "hist": line - sig})
+
+
+def bollinger(close: pd.Series, period: int = 20, std: float = 2.0) -> pd.DataFrame:
+    """Columns: mid, upper, lower, width (band width as % of mid), pct_b (0 = lower, 1 = upper)."""
+    mid = sma(close, period)
+    dev = close.rolling(period, min_periods=period).std(ddof=0)
+    upper, lower = mid + std * dev, mid - std * dev
+    span = (upper - lower).where(upper != lower)
+    return pd.DataFrame({"mid": mid, "upper": upper, "lower": lower,
+                         "width": (upper - lower) / mid * 100, "pct_b": (close - lower) / span})
+
+
+def keltner(df: pd.DataFrame, period: int = 20, atr_period: int = 10, multiplier: float = 2.0) -> pd.DataFrame:
+    """Columns: mid (EMA), upper, lower."""
+    mid = ema(df["close"], period)
+    band = multiplier * atr(df, atr_period)
+    return pd.DataFrame({"mid": mid, "upper": mid + band, "lower": mid - band})
+
+
+def donchian(df: pd.DataFrame, period: int = 20) -> pd.DataFrame:
+    """Highest high / lowest low of the previous `period` bars (excludes the current bar)."""
+    upper = df["high"].shift(1).rolling(period, min_periods=period).max()
+    lower = df["low"].shift(1).rolling(period, min_periods=period).min()
+    return pd.DataFrame({"upper": upper, "lower": lower, "mid": (upper + lower) / 2})
+
+
+def squeeze(df: pd.DataFrame, period: int = 20) -> pd.Series:
+    """True while the Bollinger band sits inside the Keltner channel (TTM squeeze)."""
+    bb, kc = bollinger(df["close"], period), keltner(df, period, period, 1.5)
+    return (bb["upper"] < kc["upper"]) & (bb["lower"] > kc["lower"])
+
+
+def adx(df: pd.DataFrame, period: int = 14) -> pd.DataFrame:
+    """Wilder's ADX. Columns: adx, plus_di, minus_di."""
+    up = df["high"].diff()
+    down = -df["low"].diff()
+    plus_dm = up.where((up > down) & (up > 0), 0.0)
+    minus_dm = down.where((down > up) & (down > 0), 0.0)
+    rng = atr(df, period)
+    smooth = lambda s: s.ewm(alpha=1 / period, adjust=False, min_periods=period).mean()  # noqa: E731
+    plus_di = 100 * smooth(plus_dm) / rng
+    minus_di = 100 * smooth(minus_dm) / rng
+    total = (plus_di + minus_di).where(lambda x: x != 0)
+    dx = 100 * (plus_di - minus_di).abs() / total
+    return pd.DataFrame({"adx": smooth(dx), "plus_di": plus_di, "minus_di": minus_di})
+
+
+def aroon(df: pd.DataFrame, period: int = 25) -> pd.DataFrame:
+    """Columns: up, down, osc (up - down). 100 = extreme set this bar."""
+    window = period + 1
+    since_high = df["high"].rolling(window, min_periods=window).apply(lambda x: period - x.argmax(), raw=True)
+    since_low = df["low"].rolling(window, min_periods=window).apply(lambda x: period - x.argmin(), raw=True)
+    up = 100 * (period - since_high) / period
+    down = 100 * (period - since_low) / period
+    return pd.DataFrame({"up": up, "down": down, "osc": up - down})
+
+
+def ichimoku(df: pd.DataFrame, tenkan: int = 9, kijun: int = 26, senkou: int = 52) -> pd.DataFrame:
+    """Columns: tenkan, kijun, span_a, span_b. Spans are already shifted
+    forward, so row i holds the cloud drawn under bar i."""
+    mid = lambda n: (df["high"].rolling(n, min_periods=n).max() + df["low"].rolling(n, min_periods=n).min()) / 2  # noqa: E731
+    t, k = mid(tenkan), mid(kijun)
+    return pd.DataFrame({"tenkan": t, "kijun": k, "span_a": ((t + k) / 2).shift(kijun),
+                         "span_b": mid(senkou).shift(kijun)})
+
+
+# ------------------------------------------------------------------ oscillators
+
+
+def stochastic(df: pd.DataFrame, period: int = 14, smooth_d: int = 3) -> pd.DataFrame:
+    """Columns: k, d (0-100)."""
+    hi = df["high"].rolling(period, min_periods=period).max()
+    lo = df["low"].rolling(period, min_periods=period).min()
+    k = 100 * (df["close"] - lo) / (hi - lo).where(hi != lo)
+    return pd.DataFrame({"k": k, "d": k.rolling(smooth_d, min_periods=smooth_d).mean()})
+
+
+def williams_r(df: pd.DataFrame, period: int = 14) -> pd.Series:
+    """-100 (at the low) .. 0 (at the high)."""
+    hi = df["high"].rolling(period, min_periods=period).max()
+    lo = df["low"].rolling(period, min_periods=period).min()
+    return -100 * (hi - df["close"]) / (hi - lo).where(hi != lo)
+
+
+def cci(df: pd.DataFrame, period: int = 20) -> pd.Series:
+    typical = (df["high"] + df["low"] + df["close"]) / 3
+    mean = typical.rolling(period, min_periods=period).mean()
+    mad = typical.rolling(period, min_periods=period).apply(lambda x: abs(x - x.mean()).mean(), raw=True)
+    return (typical - mean) / (0.015 * mad.where(mad != 0))
+
+
+def mfi(df: pd.DataFrame, period: int = 14) -> pd.Series:
+    """Money flow index (volume-weighted RSI), 0-100."""
+    typical = (df["high"] + df["low"] + df["close"]) / 3
+    flow = typical * df["volume"].fillna(0)
+    move = typical.diff()
+    pos = flow.where(move > 0, 0.0).rolling(period, min_periods=period).sum()
+    neg = flow.where(move < 0, 0.0).rolling(period, min_periods=period).sum()
+    out = 100 - 100 / (1 + pos / neg.where(neg != 0))
+    return out.where(neg != 0, 100.0).where(pos.notna())
+
+
+# ------------------------------------------------------------------ patterns
+
+
+CANDLE_PATTERNS: dict[str, tuple[str, str]] = {
+    "bullish_engulfing": ("Bullish engulfing", "bullish"),
+    "bearish_engulfing": ("Bearish engulfing", "bearish"),
+    "hammer": ("Hammer", "bullish"),
+    "shooting_star": ("Shooting star", "bearish"),
+    "morning_star": ("Morning star", "bullish"),
+    "evening_star": ("Evening star", "bearish"),
+    "doji": ("Doji", "neutral"),
+}
+
+
+def candle_patterns(df: pd.DataFrame, trend_bars: int = 5) -> list[str]:
+    """Pattern ids (keys of CANDLE_PATTERNS) completed on the last bar.
+    Reversal patterns need the preceding `trend_bars` move to point the other way."""
+    d = df.dropna(subset=["open", "high", "low", "close"])
+    if len(d) < trend_bars + 4:
+        return []
+    o, h, l, c = (d[k].astype(float).to_numpy() for k in ("open", "high", "low", "close"))
+    body = abs(c - o)
+    rng = h - l
+    avg_body = float(pd.Series(body[-11:-1]).mean()) or 1e-9
+    i = len(d) - 1
+    prior = c[i - 1] - c[i - 1 - trend_bars]  # trend into the pattern
+    down_before, up_before = prior < 0, prior > 0
+    upper = h[i] - max(o[i], c[i])
+    lower = min(o[i], c[i]) - l[i]
+    found: list[str] = []
+
+    if rng[i] > 0 and body[i] <= 0.1 * rng[i]:
+        found.append("doji")
+    if body[i] > 0 and lower >= 2 * body[i] and upper <= body[i] and down_before:
+        found.append("hammer")
+    if body[i] > 0 and upper >= 2 * body[i] and lower <= body[i] and up_before:
+        found.append("shooting_star")
+    if c[i - 1] < o[i - 1] and c[i] > o[i] and o[i] <= c[i - 1] and c[i] >= o[i - 1] and body[i] > body[i - 1] and down_before:
+        found.append("bullish_engulfing")
+    if c[i - 1] > o[i - 1] and c[i] < o[i] and o[i] >= c[i - 1] and c[i] <= o[i - 1] and body[i] > body[i - 1] and up_before:
+        found.append("bearish_engulfing")
+    first, star = i - 2, i - 1
+    if body[first] >= avg_body and body[star] <= 0.5 * body[first]:
+        if c[first] < o[first] and c[i] > o[i] and c[i] > (o[first] + c[first]) / 2 and c[first - 1] - c[first - 1 - trend_bars] < 0:
+            found.append("morning_star")
+        if c[first] > o[first] and c[i] < o[i] and c[i] < (o[first] + c[first]) / 2 and c[first - 1] - c[first - 1 - trend_bars] > 0:
+            found.append("evening_star")
+    return found
+
+
+def _swings(values, k: int, lows: bool) -> list[int]:
+    """Indexes of confirmed swing lows (or highs) with k bars each side. Strict
+    against the left side, so a flat bottom counts once (at its first bar)."""
+    out = []
+    for i in range(k, len(values) - k):
+        v, left, right = values[i], values[i - k:i], values[i + 1:i + k + 1]
+        if v != v:  # NaN
+            continue
+        if lows and all(v < x for x in left) and all(v <= x for x in right):
+            out.append(i)
+        if not lows and all(v > x for x in left) and all(v >= x for x in right):
+            out.append(i)
+    return out
+
+
+def divergence(df: pd.DataFrame, oscillator: pd.Series, lookback: int = 60, k: int = 3,
+               recent: int = 8) -> str | None:
+    """'bullish' when price makes a lower swing low while the oscillator makes a
+    higher low, 'bearish' for the mirror on swing highs. The latest swing must be
+    within `recent` bars of the end so the signal is actionable."""
+    d = df.tail(lookback)
+    osc = oscillator.reindex(d.index).to_numpy(dtype=float)
+    last = len(d) - 1
+    for lows, kind in ((True, "bullish"), (False, "bearish")):
+        price = d["low" if lows else "high"].to_numpy(dtype=float)
+        swings = [i for i in _swings(price, k, lows) if osc[i] == osc[i]]
+        if len(swings) < 2:
+            continue
+        a, b = swings[-2], swings[-1]
+        if last - b > recent or b - a < k:
+            continue
+        if lows and price[b] < price[a] and osc[b] > osc[a]:
+            return kind
+        if not lows and price[b] > price[a] and osc[b] < osc[a]:
+            return kind
+    return None

marketmyna/trading/journal.py

@@ -0,0 +1,74 @@
+"""Trade journal statistics (pure; computed from TradeRecord dicts)."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Optional
+
+
+def trade_pnl(t: dict) -> Optional[float]:
+    if t.get("exit_price") is None:
+        return None
+    sign = -1 if t.get("side") == "short" else 1
+    return (t["exit_price"] - t["entry_price"]) * t["quantity"] * sign - (t.get("fees") or 0)
+
+
+def r_multiple(t: dict) -> Optional[float]:
+    """Profit in units of the risk taken (entry-to-stop distance)."""
+    pnl = trade_pnl(t)
+    stop = t.get("stop")
+    if pnl is None or stop is None or stop == t["entry_price"]:
+        return None
+    risk = abs(t["entry_price"] - stop) * t["quantity"]
+    return pnl / risk if risk else None
+
+
+def stats(trades: list[dict]) -> dict:
+    closed = sorted((t for t in trades if t.get("exit_price") is not None),
+                    key=lambda t: t.get("exit_at") or t.get("entry_at"))
+    pnls = [trade_pnl(t) for t in closed]
+    wins = [p for p in pnls if p > 0]
+    losses = [p for p in pnls if p <= 0]
+    rs = [r for r in (r_multiple(t) for t in closed) if r is not None]
+
+    streak = worst_streak = 0
+    for p in pnls:
+        streak = streak + 1 if p <= 0 else 0
+        worst_streak = max(worst_streak, streak)
+
+    equity, running = [], 0.0
+    for t, p in zip(closed, pnls):
+        running += p
+        when = t.get("exit_at") or t.get("entry_at")
+        equity.append({"date": when.isoformat() if hasattr(when, "isoformat") else when, "pnl": round(running, 2)})
+
+    by_setup: dict[str, list[float]] = defaultdict(list)
+    for t, p in zip(closed, pnls):
+        by_setup[(t.get("setup") or "").strip() or "(none)"].append(p)
+
+    gross_loss = -sum(losses)
+    return {
+        "closed": len(closed),
+        "open": sum(1 for t in trades if t.get("exit_price") is None),
+        "wins": len(wins),
+        "losses": len(losses),
+        "win_rate": round(len(wins) / len(closed) * 100, 1) if closed else None,
+        "total_pnl": round(sum(pnls), 2),
+        "avg_win": round(sum(wins) / len(wins), 2) if wins else None,
+        "avg_loss": round(sum(losses) / len(losses), 2) if losses else None,
+        "profit_factor": round(sum(wins) / gross_loss, 2) if gross_loss > 0 else None,
+        "expectancy": round(sum(pnls) / len(pnls), 2) if pnls else None,
+        "avg_r": round(sum(rs) / len(rs), 2) if rs else None,
+        "best": round(max(pnls), 2) if pnls else None,
+        "worst": round(min(pnls), 2) if pnls else None,
+        "max_losing_streak": worst_streak,
+        "by_setup": sorted(
+            (
+                {"setup": s, "trades": len(v), "win_rate": round(sum(1 for p in v if p > 0) / len(v) * 100, 1),
+                 "pnl": round(sum(v), 2)}
+                for s, v in by_setup.items()
+            ),
+            key=lambda r: -r["pnl"],
+        ),
+        "equity": equity,
+    }

marketmyna/trading/knn.py

@@ -0,0 +1,164 @@
+"""Nearest-neighbour (kNN) signal filters, written for MarketMyna from
+general methods (k-nearest neighbours, Fisher's discriminant ratio, ATR
+bands); not a port of any published script.
+
+Everything is causal: at bar t the model only learns from rows whose
+outcome was already known at t, so a backtest never sees the future.
+
+  analog_score   for each bar, find the k most similar past market states
+                 (trend, stretch, momentum, volatility, position in the bar's
+                 range, short slope) and average what happened next
+                 (+1 / -1, weighted by similarity). Features are weighted by
+                 how well they separated up from down outcomes in the memory
+                 (Fisher ratio), so useless features count less.
+  crossover_vote for moving-average crossovers: each past crossover is stored
+                 with its ADX and MFI and whether the trade that followed
+                 made money; a new crossover gets the sum of the votes of its
+                 k nearest past crossovers.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from . import indicators as ind
+
+FEATURES = ("trend", "stretch", "momentum", "volatility", "range_pos", "slope")
+
+
+def features(df: pd.DataFrame) -> pd.DataFrame:
+    """Six bounded features per bar (each roughly in -1..1)."""
+    close, high, low = df["close"], df["high"], df["low"]
+    atr = ind.atr(df, 14).replace(0, np.nan)
+    trend = ((ind.ema(close, 10) - ind.ema(close, 34)) / atr).clip(-3, 3) / 3
+    basis, dev = close.rolling(30).mean(), close.rolling(30).std().replace(0, np.nan)
+    stretch = (-(close - basis) / dev).clip(-3, 3) / 3  # stretched up -> negative
+    momentum = ((close / close.shift(14) - 1) / 0.05).clip(-3, 3) / 3
+    vol = close.rolling(20).std()
+    lo, hi = vol.rolling(100).min(), vol.rolling(100).max()
+    volatility = (((vol - lo) / (hi - lo).replace(0, np.nan)).clip(0, 1) * 2 - 1)
+    rng = (high - low).replace(0, np.nan)
+    range_pos = (((close - low) / rng) * 2 - 1).clip(-1, 1)
+    slope = ((close - close.shift(3)) / atr).clip(-3, 3) / 3
+    return pd.DataFrame({"trend": trend, "stretch": stretch, "momentum": momentum, "volatility": volatility,
+                         "range_pos": range_pos, "slope": slope}, index=df.index)
+
+
+def outcomes(df: pd.DataFrame, horizon: int, atr_band: float) -> pd.Series:
+    """+1 / -1 when the close `horizon` bars later moved more than atr_band x ATR
+    up / down, 0 for a flat outcome (not learned from). Known only at t + horizon."""
+    move = df["close"].shift(-horizon) - df["close"]
+    band = atr_band * ind.atr(df, 14)
+    return pd.Series(np.where(move > band, 1.0, np.where(move < -band, -1.0, 0.0)), index=df.index).where(move.notna())
+
+
+def fisher_weights(x: np.ndarray, y: np.ndarray, floor: float = 0.4) -> np.ndarray:
+    """Per-feature (mean_up - mean_down)^2 / (var_up + var_down), scaled so the
+    best feature gets 1; `floor` keeps every feature in play."""
+    up, dn = x[y > 0], x[y < 0]
+    if len(up) < 5 or len(dn) < 5:
+        return np.ones(x.shape[1])
+    f = (up.mean(0) - dn.mean(0)) ** 2 / (up.var(0) + dn.var(0) + 1e-9)
+    return np.maximum(floor, f / f.max()) if f.max() > 0 else np.ones(x.shape[1])
+
+
+def analog_score(df: pd.DataFrame, horizon: int = 4, k: int = 9, memory: int = 400, atr_band: float = 0.45,
+                 min_rows: int = 60, refit_every: int = 20) -> pd.DataFrame:
+    """Columns: score (-1..1, similarity-weighted average outcome of the k
+    nearest past states) and agree (share of that weight on the winning side)."""
+    feats = features(df)
+    out_lbl = outcomes(df, horizon, atr_band)
+    x_all = feats.to_numpy(dtype=float)
+    y_all = out_lbl.to_numpy(dtype=float)
+    n = len(df)
+    score = np.full(n, np.nan)
+    agree = np.full(n, np.nan)
+    weights = np.ones(len(FEATURES))
+    for t in range(n):
+        xt = x_all[t]
+        if np.isnan(xt).any():
+            continue
+        last_known = t - horizon  # rows up to here have a known outcome at bar t
+        lo = max(0, last_known - memory + 1)
+        if last_known - lo + 1 < min_rows:
+            continue
+        xs, ys = x_all[lo:last_known + 1], y_all[lo:last_known + 1]
+        ok = ~np.isnan(xs).any(axis=1) & ~np.isnan(ys) & (ys != 0)
+        xs, ys = xs[ok], ys[ok]
+        if len(ys) < max(k, 10):
+            continue
+        if t % refit_every == 0:
+            weights = fisher_weights(xs, ys)
+        dist = (np.log1p(np.abs(xs - xt)) * weights).sum(axis=1)
+        idx = np.argpartition(dist, min(k, len(dist) - 1))[:k]
+        w = 1.0 / (1.0 + dist[idx])
+        s = float((ys[idx] * w).sum() / w.sum())
+        score[t] = s
+        side = ys[idx] > 0 if s >= 0 else ys[idx] < 0
+        agree[t] = float(w[side].sum() / w.sum())
+    return pd.DataFrame({"score": score, "agree": agree}, index=df.index)
+
+
+def adaptive_supertrend(df: pd.DataFrame, confidence: pd.Series, period: int = 10, multiplier: float = 2.0,
+                        adapt: float = 0.8) -> tuple[pd.Series, pd.Series]:
+    """Supertrend whose band widens when the model is unsure (confidence near 0)
+    and tightens toward `multiplier` when it is sure: mult x (1 + adapt x (1 - conf))."""
+    close = df["close"].to_numpy(dtype=float)
+    hl2 = ((df["high"] + df["low"]) / 2).to_numpy(dtype=float)
+    atr = ind.atr(df, period).to_numpy(dtype=float)
+    conf = confidence.fillna(0).clip(0, 1).to_numpy(dtype=float)
+    mult = multiplier * (1 + adapt * (1 - conf))
+    n = len(df)
+    line = np.full(n, np.nan)
+    direction = np.zeros(n)
+    up = dn = np.nan
+    d = 1
+    for i in range(n):
+        if np.isnan(atr[i]):
+            continue
+        lower, upper = hl2[i] - mult[i] * atr[i], hl2[i] + mult[i] * atr[i]
+        up = lower if np.isnan(up) or close[i - 1] <= up else max(lower, up)
+        dn = upper if np.isnan(dn) or close[i - 1] >= dn else min(upper, dn)
+        if d == -1 and close[i] > dn:
+            d = 1
+        elif d == 1 and close[i] < up:
+            d = -1
+        direction[i] = d
+        line[i] = up if d == 1 else dn
+    return pd.Series(line, index=df.index), pd.Series(direction, index=df.index)
+
+
+def vwma(df: pd.DataFrame, period: int) -> pd.Series:
+    vol = df["volume"].astype(float)
+    return (df["close"] * vol).rolling(period).sum() / vol.rolling(period).sum().replace(0, np.nan)
+
+
+def crossover_vote(df: pd.DataFrame, fast: int = 13, slow: int = 19, k: int = 23, filter_len: int = 13) -> pd.DataFrame:
+    """For every bar: cross (+1 up / -1 down / 0) and, on cross bars, the vote of
+    the k nearest past crossovers in (ADX, MFI) space. A past crossover's label
+    is +1 when price at the following crossover was higher (the move it started
+    went up), known only once that following crossover has happened."""
+    f, s = vwma(df, fast), vwma(df, slow)
+    above = (f > s).astype(int)
+    cross = above.diff().fillna(0)
+    adx = ind.adx(df, filter_len)["adx"]
+    mfi = ind.mfi(df, filter_len)
+    close = df["close"].to_numpy(dtype=float)
+    feats: list[tuple[float, float]] = []
+    labels: list[float] = []
+    prev = None  # (adx, mfi, price) of the last crossover, label pending
+    vote = np.full(len(df), np.nan)
+    for i, c in enumerate(cross.to_numpy()):
+        if c == 0 or np.isnan(adx.iloc[i]) or np.isnan(mfi.iloc[i]):
+            continue
+        a, m = float(adx.iloc[i]) / 100, float(mfi.iloc[i]) / 100
+        if feats:
+            d = np.hypot(np.array([p[0] for p in feats]) - a, np.array([p[1] for p in feats]) - m)
+            idx = np.argsort(d)[:k]
+            vote[i] = float(np.array(labels)[idx].sum())
+        if prev is not None:  # the previous crossover's outcome is known now
+            feats.append((prev[0], prev[1]))
+            labels.append(1.0 if close[i] >= prev[2] else -1.0)
+        prev = (a, m, close[i])
+    return pd.DataFrame({"cross": cross, "vote": vote}, index=df.index)

marketmyna/trading/lots.py

@@ -0,0 +1,109 @@
+"""NSE F&O lot sizes from brokers' public instrument files.
+
+NSE only publishes lot sizes as a PDF and revises them every few months,
+so they're read from Upstox's public instrument dump (Kite's as a
+fallback), cached on disk for a day. Lot sizes can differ by expiry around
+a revision, hence {symbol: {expiry: lot}}."""
+
+from __future__ import annotations
+
+import csv
+import gzip
+import io
+import json
+import logging
+import threading
+import time
+from datetime import date, datetime
+from pathlib import Path
+from typing import Optional
+from zoneinfo import ZoneInfo
+
+from marketmyna.core.home import app_home
+
+logger = logging.getLogger(__name__)
+
+UPSTOX_URL = "https://assets.upstox.com/market-quote/instruments/exchange/NSE.json.gz"
+KITE_URL = "https://api.kite.trade/instruments/NFO"
+MAX_AGE = 24 * 3600
+IST = ZoneInfo("Asia/Kolkata")
+
+_lock = threading.Lock()
+_memory: Optional[tuple[float, dict]] = None
+
+
+def _cache_path() -> Path:
+    return app_home() / "cache" / "fo_lots.json"
+
+
+def _from_upstox() -> dict[str, dict[str, int]]:
+    import requests
+
+    r = requests.get(UPSTOX_URL, timeout=30)
+    r.raise_for_status()
+    out: dict[str, dict[str, int]] = {}
+    for d in json.loads(gzip.decompress(r.content)):
+        if d.get("segment") != "NSE_FO" or not d.get("lot_size"):
+            continue
+        sym = (d.get("underlying_symbol") or d.get("name") or "").upper()
+        exp = datetime.fromtimestamp(d["expiry"] / 1000, IST).date().isoformat() if d.get("expiry") else ""
+        out.setdefault(sym, {})[exp] = int(d["lot_size"])
+    return out
+
+
+def _from_kite() -> dict[str, dict[str, int]]:
+    import requests
+
+    r = requests.get(KITE_URL, timeout=30)
+    r.raise_for_status()
+    out: dict[str, dict[str, int]] = {}
+    for row in csv.DictReader(io.StringIO(r.text)):
+        if row.get("lot_size") and row.get("name"):
+            out.setdefault(row["name"].upper(), {})[row.get("expiry", "")] = int(float(row["lot_size"]))
+    return out
+
+
+def load(force: bool = False) -> dict[str, dict[str, int]]:
+    global _memory
+    with _lock:
+        if not force and _memory and time.time() - _memory[0] < MAX_AGE:
+            return _memory[1]
+        path = _cache_path()
+        if not force and path.exists() and time.time() - path.stat().st_mtime < MAX_AGE:
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+                _memory = (path.stat().st_mtime, data)
+                return data
+            except ValueError:
+                pass
+        data: dict = {}
+        for source in (_from_upstox, _from_kite):
+            try:
+                data = source()
+                if data:
+                    break
+            except Exception as exc:
+                logger.warning("Lot sizes from %s failed: %s", source.__name__, exc)
+        if data:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(json.dumps(data), encoding="utf-8")
+            _memory = (time.time(), data)
+            return data
+        if path.exists():  # stale beats nothing
+            return json.loads(path.read_text(encoding="utf-8"))
+        return {}
+
+
+def lot_size(symbol: str, expiry: Optional[date] = None, data: Optional[dict] = None) -> Optional[int]:
+    """Lot for `symbol` at `expiry` (or its nearest listed expiry)."""
+    by_expiry = (data if data is not None else load()).get(symbol.upper())
+    if not by_expiry:
+        return None
+    if expiry is not None and expiry.isoformat() in by_expiry:
+        return by_expiry[expiry.isoformat()]
+    dated = sorted(k for k in by_expiry if k)
+    if not dated:
+        return next(iter(by_expiry.values()))
+    target = (expiry or date.today()).isoformat()
+    upcoming = [k for k in dated if k >= target]
+    return by_expiry[(upcoming or dated)[0] if upcoming else dated[-1]]