Skip to content

reddygopalkrishna/trading-skills / skills/trading-entry

trading-entry

Verified

Entry timer for intraday setups in any market - watches bar by bar and says the moment a setup triggers, waiting (and how far), still forming, expired or market closed. Opening-range breakout (first 15 minutes by default) or a break of any level you give, long or short, on 1, 2, 5 or 15-minute bars, with an optional volume check and a no-entries-near-the-close cutoff. Reads each exchange's session from the data (NSE 09:15, NYSE 09:30, LSE 08:00...), replays past sessions for practice, and hands the trigger to trading-plan with stop ideas. Never places an order. Use when the user says "tell me when to get in", "watch RELIANCE", "has it broken out", "did it break the opening range", "time my entry", "ORB", "check my watchlist for breakouts", or after a scan finds a setup.

FileKindSize
SKILL.mdskill md3.9 KB
assets/watchlists/crypto-majors.txtmarkdown112 B
assets/watchlists/global-index-etfs.txtmarkdown106 B
assets/watchlists/global-large-caps.txtmarkdown306 B
assets/watchlists/india-large-caps.txtmarkdown291 B
assets/watchlists/us-mega-caps.txtmarkdown173 B
assets/watchlists/world-indices.txtmarkdown104 B
scripts/_vendor/tradekit/__init__.pyscript516 B
scripts/_vendor/tradekit/alerts.pyscript7.5 KB
scripts/_vendor/tradekit/analysis.pyscript10.3 KB
scripts/_vendor/tradekit/backtest.pyscript17.8 KB
scripts/_vendor/tradekit/brokers/__init__.pyscript1022 B
scripts/_vendor/tradekit/brokers/_rest.pyscript2.7 KB
scripts/_vendor/tradekit/brokers/base.pyscript3.5 KB
scripts/_vendor/tradekit/brokers/dhan.pyscript6.8 KB
scripts/_vendor/tradekit/brokers/fyers.pyscript7.1 KB
scripts/_vendor/tradekit/brokers/groww.pyscript7.7 KB
scripts/_vendor/tradekit/brokers/kite.pyscript14.5 KB
scripts/_vendor/tradekit/brokers/paper.pyscript12.7 KB
scripts/_vendor/tradekit/brokers/upstox.pyscript7.8 KB
scripts/_vendor/tradekit/cli.pyscript2.4 KB
scripts/_vendor/tradekit/config.pyscript6.0 KB
scripts/_vendor/tradekit/data.pyscript18.5 KB
scripts/_vendor/tradekit/disclosures.pyscript17.4 KB
scripts/_vendor/tradekit/expr.pyscript19.0 KB
scripts/_vendor/tradekit/feeds.pyscript9.4 KB
scripts/_vendor/tradekit/frame.pyscript8.9 KB
scripts/_vendor/tradekit/fundamentals.pyscript6.1 KB
scripts/_vendor/tradekit/gate.pyscript8.1 KB
scripts/_vendor/tradekit/http.pyscript4.3 KB
scripts/_vendor/tradekit/indicators.pyscript13.1 KB
scripts/_vendor/tradekit/journal.pyscript11.1 KB
scripts/_vendor/tradekit/metrics.pyscript6.2 KB
scripts/_vendor/tradekit/montecarlo.pyscript7.8 KB
scripts/_vendor/tradekit/options.pyscript24.4 KB
scripts/_vendor/tradekit/patterns.pyscript12.9 KB
scripts/_vendor/tradekit/report.pyscript8.4 KB
scripts/_vendor/tradekit/risk.pyscript4.7 KB
scripts/_vendor/tradekit/sec.pyscript12.0 KB
scripts/_vendor/tradekit/session.pyscript9.4 KB
scripts/entry.pyscript8.1 KB

scripts/_vendor/tradekit/backtest.py

View on GitHub
"""Portfolio trading-backtest for rule-based strategies.

Execution model (no look-ahead):
    * Rules are evaluated on the CLOSE of bar t.
    * Entries and rule-based exits fill at the OPEN of the symbol's next bar, plus slippage.
    * Stops fill at the stop price, or at the open if the bar gaps through it, plus slippage.
    * Targets fill at the target price (or the open on a favourable gap). No slippage on targets.
    * If a bar touches both stop and target, the stop is assumed to fill first (conservative).
    * The entry bar itself can stop out.
    * max_bars exits at the close of the Nth bar held.
    * Positions still open at the end are closed at the last close (flagged end_of_data).

Strategy spec (JSON) - see SPEC_DEFAULTS and skills/trading-backtest/references/strategy-spec.md
"""

from __future__ import annotations

import copy
import math
from typing import Dict, List, Optional

from . import expr, indicators as ind, metrics
from .frame import Bars

SPEC_DEFAULTS: Dict = {
    "name": "strategy",
    "side": "long",                      # long | short
    "entry": None,                       # rule (required)
    "exit": None,                        # optional rule
    "stop": {"type": "atr", "mult": 2.0, "n": 14},   # atr | pct | expr | none
    "target": None,                      # {"type": "r", "value": 2} | {"type": "pct", "value": 10} | {"type":"expr",...}
    "trail": None,                       # {"type": "atr", "mult": 3, "n": 14} | {"type": "pct", "value": 8}
    "max_bars": None,
    "sizing": {"type": "risk", "risk_pct": 1.0},     # risk | percent | fixed
    "max_positions": 5,
    "max_position_pct": 25.0,
    "rank_by": None,                     # rule; higher ranks first when slots are limited
    "initial_capital": 100000.0,
    "costs": {"commission_pct": 0.03, "commission_fixed": 0.0, "slippage_pct": 0.05},
    "lot_size": 1,
    "fractional": False,
    "periods_per_year": None,            # auto: 252 daily, 52 weekly, 12 monthly
    "oos_start": None,                   # date splitting in-sample / out-of-sample
}


class BacktestError(ValueError):
    pass


def normalize_spec(spec: Dict) -> Dict:
    s = copy.deepcopy(SPEC_DEFAULTS)
    for k, v in spec.items():
        if isinstance(v, dict) and isinstance(s.get(k), dict):
            s[k].update(v)
        else:
            s[k] = v
    if not s.get("entry"):
        raise BacktestError("spec needs an 'entry' rule")
    if s["side"] not in ("long", "short"):
        raise BacktestError("side must be long or short")
    expr.compile_expr(s["entry"])
    if s.get("exit"):
        expr.compile_expr(s["exit"])
    if s.get("rank_by"):
        expr.compile_expr(s["rank_by"])
    st = s.get("stop") or {"type": "none"}
    if isinstance(st, str):
        st = {"type": "expr", "value": st}
    s["stop"] = st
    if st["type"] == "expr":
        expr.compile_expr(st["value"])
    if st["type"] not in ("atr", "pct", "expr", "none"):
        raise BacktestError("stop.type must be atr | pct | expr | none")
    if s["sizing"]["type"] == "risk" and st["type"] == "none":
        raise BacktestError("risk-based sizing needs a stop; use sizing.type=percent or add a stop")
    tg = s.get("target")
    if tg and tg.get("type") == "expr":
        expr.compile_expr(tg["value"])
    return s


class _Sym:
    def __init__(self, bars: Bars, spec: Dict):
        self.bars = bars
        ev = expr.Evaluator(bars)
        self.entry = expr.as_bool(ev.series(spec["entry"]))
        self.exit = expr.as_bool(ev.series(spec["exit"])) if spec.get("exit") else None
        self.rank = ev.series(spec["rank_by"]) if spec.get("rank_by") else None
        st = spec["stop"]
        self.atr = None
        if st["type"] == "atr":
            self.atr = ind.atr(bars.high, bars.low, bars.close, int(st.get("n", 14)))
        self.stop_expr = ev.series(st["value"]) if st["type"] == "expr" else None
        tg = spec.get("target") or {}
        self.target_expr = ev.series(tg["value"]) if tg.get("type") == "expr" else None
        tr = spec.get("trail") or {}
        self.trail_atr = ind.atr(bars.high, bars.low, bars.close, int(tr.get("n", 14))) if tr.get("type") == "atr" else None
        self.index = {d: i for i, d in enumerate(bars.date)}


def run(spec: Dict, data: Dict[str, Bars], benchmark: Optional[Bars] = None) -> Dict:
    s = normalize_spec(spec)
    if not data:
        raise BacktestError("no data to backtest")
    syms = {k: _Sym(b, s) for k, b in data.items() if len(b) > 1}
    if not syms:
        raise BacktestError("every symbol has fewer than 2 bars")
    dates = sorted({d for x in syms.values() for d in x.bars.date})
    long = s["side"] == "long"
    sign = 1 if long else -1
    c = s["costs"]
    slip = float(c.get("slippage_pct", 0)) / 100
    com_pct = float(c.get("commission_pct", 0)) / 100
    com_fix = float(c.get("commission_fixed", 0))
    lot = float(s.get("lot_size") or 1)
    fractional = bool(s.get("fractional"))

    cash = float(s["initial_capital"])
    positions: Dict[str, Dict] = {}
    pending_entry: Dict[str, int] = {}
    pending_exit: Dict[str, int] = {}
    last_close: Dict[str, float] = {}
    trades: List[Dict] = []
    equity_curve: List[float] = []
    exposure_bars = 0
    skipped_slots = 0

    def fee(notional: float) -> float:
        return abs(notional) * com_pct + com_fix

    def adverse(px: float, is_entry: bool) -> float:
        # entry long buys higher; exit long sells lower; mirrored for short
        buying = (long and is_entry) or (not long and not is_entry)
        return px * (1 + slip) if buying else px * (1 - slip)

    def close_pos(sym: str, px: float, date: str, i: int, reason: str, apply_slip: bool = True):
        nonlocal cash
        p = positions.pop(sym)
        fill = adverse(px, False) if apply_slip else px
        f = fee(fill * p["qty"])
        cash += sign * p["qty"] * fill - f
        gross = (fill - p["entry_price"]) * p["qty"] * sign
        net = gross - f - p["entry_fee"]
        risk_amt = p["risk_per_unit"] * p["qty"] if p["risk_per_unit"] else None
        bars_held = i - p["entry_i"] + 1
        trades.append({
            "symbol": sym, "side": s["side"], "entry_date": p["entry_date"], "entry_price": round(p["entry_price"], 6),
            "exit_date": date, "exit_price": round(fill, 6), "qty": p["qty"],
            "initial_stop": round(p["initial_stop"], 6) if p["initial_stop"] else None,
            "pnl": round(net, 2), "return_pct": round((fill / p["entry_price"] - 1) * 100 * sign, 3),
            "r_multiple": round(net / risk_amt, 3) if risk_amt else None,
            "bars_held": bars_held, "exit_reason": reason,
            "mae_r": round(p["mae"] / p["risk_per_unit"], 3) if p["risk_per_unit"] else None,
            "mfe_r": round(p["mfe"] / p["risk_per_unit"], 3) if p["risk_per_unit"] else None,
        })

    for d in dates:
        # ---------------- 1. manage open positions on this bar
        for sym in list(positions):
            x = syms[sym]
            i = x.index.get(d)
            if i is None:
                continue
            p = positions[sym]
            o, h, l, cl = x.bars.open[i], x.bars.high[i], x.bars.low[i], x.bars.close[i]
            if i > p["entry_i"]:
                if sym in pending_exit:
                    pending_exit.pop(sym)
                    close_pos(sym, o, d, i, "exit_rule")
                    continue
            # excursions
            p["mae"] = max(p["mae"], (p["entry_price"] - l) if long else (h - p["entry_price"]))
            p["mfe"] = max(p["mfe"], (h - p["entry_price"]) if long else (p["entry_price"] - l))
            stop, target = p["stop"], p["target"]
            px = None
            reason = None
            apply_slip = True
            first_bar = i == p["entry_i"]
            if stop is not None:
                if long:
                    if not first_bar and o <= stop:
                        px, reason = o, "stop_gap"
                    elif l <= stop:
                        px, reason = stop, "stop"
                else:
                    if not first_bar and o >= stop:
                        px, reason = o, "stop_gap"
                    elif h >= stop:
                        px, reason = stop, "stop"
            if px is None and target is not None:
                if long:
                    if not first_bar and o >= target:
                        px, reason, apply_slip = o, "target_gap", False
                    elif h >= target:
                        px, reason, apply_slip = target, "target", False
                else:
                    if not first_bar and o <= target:
                        px, reason, apply_slip = o, "target_gap", False
                    elif l <= target:
                        px, reason, apply_slip = target, "target", False
            if px is not None:
                close_pos(sym, px, d, i, reason, apply_slip)
                continue
            if s.get("max_bars") and (i - p["entry_i"] + 1) >= int(s["max_bars"]):
                close_pos(sym, cl, d, i, "max_bars")
                continue
            # trailing stop update at close (applies from the next bar)
            tr = s.get("trail")
            if tr and tr.get("type"):
                if tr["type"] == "atr" and x.trail_atr and x.trail_atr[i] is not None:
                    cand = cl - sign * float(tr.get("mult", 3)) * x.trail_atr[i]
                elif tr["type"] == "pct":
                    cand = cl * (1 - sign * float(tr["value"]) / 100)
                else:
                    cand = None
                if cand is not None:
                    if p["stop"] is None:
                        p["stop"] = cand
                    else:
                        p["stop"] = max(p["stop"], cand) if long else min(p["stop"], cand)

        # ---------------- 2. new entries at this bar's open (signals from previous bar)
        cands = []
        for sym, sig_i in list(pending_entry.items()):
            x = syms[sym]
            i = x.index.get(d)
            if i is None:
                continue
            pending_entry.pop(sym)
            if i != sig_i + 1 or sym in positions:
                continue
            rank = x.rank[sig_i] if x.rank else 0.0
            cands.append((rank if rank is not None else -math.inf, sym, i, sig_i))
        cands.sort(key=lambda t: t[0], reverse=True)
        for _, sym, i, sig_i in cands:
            if len(positions) >= int(s["max_positions"]):
                skipped_slots += 1
                continue
            x = syms[sym]
            o = x.bars.open[i]
            entry_px = adverse(o, True)
            st = s["stop"]
            stop = None
            if st["type"] == "atr":
                a = x.atr[sig_i]
                if a is None:
                    continue
                stop = entry_px - sign * float(st.get("mult", 2)) * a
            elif st["type"] == "pct":
                stop = entry_px * (1 - sign * float(st["value"]) / 100)
            elif st["type"] == "expr":
                stop = x.stop_expr[sig_i]
                if stop is None:
                    continue
            if stop is not None and ((long and stop >= entry_px) or (not long and stop <= entry_px)):
                continue  # invalid stop (e.g. gapped through) - skip trade
            equity_now = cash + sum(sign * q["qty"] * last_close.get(k, q["entry_price"]) for k, q in positions.items())
            sz = s["sizing"]
            if sz["type"] == "risk":
                budget = equity_now * float(sz.get("risk_pct", 1)) / 100
                units = budget / abs(entry_px - stop)
            elif sz["type"] == "percent":
                units = equity_now * float(sz.get("pct", 10)) / 100 / entry_px
            elif sz["type"] == "fixed":
                units = float(sz["amount"]) / entry_px
            else:
                raise BacktestError("sizing.type must be risk | percent | fixed")
            cap = equity_now * float(s.get("max_position_pct") or 100) / 100 / entry_px
            units = min(units, cap)
            if long:
                units = min(units, max(cash, 0) / (entry_px * (1 + com_pct)))
            units = math.floor(units / lot + 1e-9) * lot if not fractional else units
            if units <= 0:
                continue
            target = None
            tg = s.get("target") or {}
            if tg.get("type") == "r" and stop is not None:
                target = entry_px + sign * float(tg["value"]) * abs(entry_px - stop)
            elif tg.get("type") == "pct":
                target = entry_px * (1 + sign * float(tg["value"]) / 100)
            elif tg.get("type") == "expr":
                target = x.target_expr[sig_i]
            f = fee(entry_px * units)
            cash -= sign * units * entry_px + f
            positions[sym] = {"qty": units, "entry_price": entry_px, "entry_i": i, "entry_date": d,
                              "stop": stop, "initial_stop": stop, "target": target, "entry_fee": f,
                              "risk_per_unit": abs(entry_px - stop) if stop is not None else None,
                              "mae": 0.0, "mfe": 0.0}
            # same-bar stop/target check after entry
            h, l = x.bars.high[i], x.bars.low[i]
            p = positions[sym]
            p["mae"] = max(0.0, (entry_px - l) if long else (h - entry_px))
            p["mfe"] = max(0.0, (h - entry_px) if long else (entry_px - l))
            if stop is not None and ((long and l <= stop) or (not long and h >= stop)):
                close_pos(sym, stop, d, i, "stop")
            elif target is not None and ((long and h >= target) or (not long and l <= target)):
                close_pos(sym, target, d, i, "target", apply_slip=False)

        # ---------------- 3. mark to market
        for sym, x in syms.items():
            i = x.index.get(d)
            if i is not None:
                last_close[sym] = x.bars.close[i]
        eq = cash + sum(sign * p["qty"] * last_close.get(k, p["entry_price"]) for k, p in positions.items())
        equity_curve.append(eq)
        if positions:
            exposure_bars += 1

        # ---------------- 4. signals at this close for the next bar
        for sym, x in syms.items():
            i = x.index.get(d)
            if i is None:
                continue
            if sym in positions:
                if x.exit and x.exit[i]:
                    pending_exit[sym] = i
            elif x.entry[i] and i + 1 < len(x.bars):
                pending_entry[sym] = i

    # close anything still open
    for sym in list(positions):
        x = syms[sym]
        close_pos(sym, x.bars.close[-1], x.bars.date[-1], len(x.bars) - 1, "end_of_data", apply_slip=True)
    if positions == {} and equity_curve:
        equity_curve[-1] = cash

    ppy = s.get("periods_per_year") or _ppy(next(iter(data.values())).interval)
    eq_stats = metrics.equity_stats(equity_curve, dates, ppy)
    tr_stats = metrics.trade_stats(trades)
    result = {
        "name": s["name"], "spec": s, "symbols": sorted(syms),
        "metrics": {**eq_stats, **tr_stats,
                    "exposure_pct": round(exposure_bars / len(dates) * 100, 2) if dates else 0,
                    "skipped_for_slots": skipped_slots},
        "trades": trades,
        "equity": [[d, round(v, 2)] for d, v in zip(dates, equity_curve)],
        "warnings": _warnings(s, trades, data),
    }
    if s.get("oos_start"):
        result["in_sample"] = _segment(dates, equity_curve, trades, None, s["oos_start"], ppy)
        result["out_of_sample"] = _segment(dates, equity_curve, trades, s["oos_start"], None, ppy)
    bm = _benchmark(benchmark, data, dates, float(s["initial_capital"]), ppy)
    if bm:
        result["benchmark"] = bm
    return result


def _ppy(interval: str) -> int:
    return {"1wk": 52, "1mo": 12}.get(interval, 252)


def _segment(dates, equity, trades, start, end, ppy) -> Dict:
    idx = [k for k, d in enumerate(dates) if (start is None or d >= start) and (end is None or d < end)]
    if len(idx) < 2:
        return {"note": "not enough bars in segment"}
    eq = [equity[k] for k in idx]
    ds = [dates[k] for k in idx]
    tr = [t for t in trades if (start is None or t["entry_date"] >= start) and (end is None or t["entry_date"] < end)]
    return {**metrics.equity_stats(eq, ds, ppy), **metrics.trade_stats(tr)}


def _benchmark(bm: Optional[Bars], data: Dict[str, Bars], dates: List[str], capital: float, ppy: int) -> Optional[Dict]:
    if bm is not None and len(bm) > 1:
        series = bm.since(dates[0]).until(dates[-1])
        if len(series) > 1:
            eq = [capital * c / series.close[0] for c in series.close]
            st = metrics.equity_stats(eq, series.date, ppy)
            return {"symbol": bm.symbol, "total_return_pct": st.get("total_return_pct"), "cagr_pct": st.get("cagr_pct"),
                    "max_drawdown_pct": st.get("max_drawdown_pct"), "sharpe": st.get("sharpe"),
                    "equity": [[d, round(v, 2)] for d, v in zip(series.date, eq)]}
    # equal-weight buy & hold of the universe
    rets = []
    for b in data.values():
        if len(b) > 1:
            rets.append(b.close[-1] / b.close[0] - 1)
    if not rets:
        return None
    return {"symbol": "equal_weight_universe", "total_return_pct": round(sum(rets) / len(rets) * 100, 3)}


def _warnings(s: Dict, trades: List[Dict], data: Dict[str, Bars]) -> List[str]:
    w = []
    n = len(trades)
    if n < 30:
        w.append(f"Only {n} trades - results are not statistically meaningful (aim for 100+).")
    if any(not b.meta.get("adjusted", True) for b in data.values()):
        w.append("Some data is unadjusted for splits/dividends - long-history results may be distorted.")
    w.append("Universe chosen today has survivorship bias (delisted losers are missing). Treat results as optimistic.")
    if float(s["costs"].get("slippage_pct", 0)) == 0 and float(s["costs"].get("commission_pct", 0)) == 0:
        w.append("Zero costs assumed - real results will be worse.")
    if not s.get("oos_start"):
        w.append("No out-of-sample split. Set oos_start to check the rules hold on unseen data.")
    return w
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall