Skip to content

reddygopalkrishna/trading-skills / skills/trading-scanner

trading-scanner

Verified

Screen any list of stocks, ETFs, crypto or FX pairs with plain-English ideas turned into precise rules (or 14 ready presets like trend-template, momentum-leaders, breakout-volume, oversold-in-uptrend, squeeze, golden-cross), then rank the matches with key columns. Use when the user asks to find, filter or scan for stocks, "which of these are near highs", "show oversold names in an uptrend", wants a watchlist built from criteria, or describes conditions to search for.

FileKindSize
SKILL.mdskill md2.6 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
references/rule-language.mdmarkdown2.9 KB
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/screen.pyscript8.5 KB

scripts/_vendor/tradekit/data.py

View on GitHub
"""Market data providers with a local cache.

Providers
    yahoo  Free, no API key. Unofficial Yahoo Finance chart endpoint. Covers most
           global stocks, ETFs, indices (^GSPC), FX (EURUSD=X), crypto (BTC-USD).
           Exchange suffixes follow Yahoo conventions (e.g. .L, .TO, .NS, .T, .HK).
           Data can be delayed, adjusted or rate limited - verify before trading.
    csv    Your own files: <csv_dir>/<SYMBOL>.csv with date,open,high,low,close,volume.
    kite   Zerodha Kite Connect historical API (requires the paid data plan).
           Symbols as EXCHANGE:TRADINGSYMBOL, e.g. NSE:INFY.
"""

from __future__ import annotations

import datetime as dt
import json
import time
import urllib.parse
from pathlib import Path
from typing import Dict, Iterable, List, Optional, Sequence

from . import config, http
from .frame import Bars, normalize_date

INTERVALS = ("1m", "2m", "5m", "15m", "30m", "60m", "1h", "1d", "1wk", "1mo")
PERIODS = ("1d", "5d", "1mo", "3mo", "6mo", "1y", "2y", "5y", "10y", "max")

# Yahoo intraday history limits (days)
_YAHOO_INTRADAY_MAX_DAYS = {"1m": 7, "2m": 60, "5m": 60, "15m": 60, "30m": 60, "60m": 730, "1h": 730}


class DataError(RuntimeError):
    pass


def period_days(period: str) -> int:
    table = {"1d": 1, "5d": 5, "1mo": 31, "3mo": 92, "6mo": 183, "1y": 366, "2y": 731,
             "5y": 1827, "10y": 3653, "max": 36500}
    if period not in table:
        raise DataError(f"unknown period {period!r}; use one of {', '.join(PERIODS)}")
    return table[period]


def _local(epoch: int, gmtoff: int, fmt: str = "%Y-%m-%dT%H:%M") -> str:
    return dt.datetime.fromtimestamp(int(epoch) + int(gmtoff), dt.timezone.utc).strftime(fmt)


def parse_yahoo_chart(payload: Dict, symbol: str, interval: str = "1d") -> Bars:
    """Yahoo v8 chart JSON -> Bars. Times are the exchange's local time. meta carries the
    exchange's regular sessions (sessions: [{date, open, close}]) so intraday tools need no
    holiday tables: a day with no session is a day the market was closed."""
    chart = (payload or {}).get("chart", {})
    if chart.get("error"):
        raise DataError(f"Yahoo error for {symbol}: {chart['error'].get('description', chart['error'])}")
    results = chart.get("result") or []
    if not results:
        raise DataError(f"no data returned for {symbol}")
    r = results[0]
    ts = r.get("timestamp") or []
    q = (r.get("indicators", {}).get("quote") or [{}])[0]
    adj = (r.get("indicators", {}).get("adjclose") or [{}])[0].get("adjclose")
    meta = r.get("meta", {})
    gmtoff = int(meta.get("gmtoffset") or 0)
    daily = interval in ("1d", "1wk", "1mo")
    rows = []
    for i, t in enumerate(ts):
        o, h, l, c, v = (q.get(k, [None] * len(ts))[i] for k in ("open", "high", "low", "close", "volume"))
        if c is None:
            continue
        factor = 1.0
        if adj and adj[i] and daily:
            factor = adj[i] / c if c else 1.0
        d = _local(t, gmtoff, "%Y-%m-%d" if daily else "%Y-%m-%dT%H:%M")
        rows.append({"date": d,
                     "open": (o if o is not None else c) * factor,
                     "high": (h if h is not None else c) * factor,
                     "low": (l if l is not None else c) * factor,
                     "close": c * factor, "volume": v or 0})
    sessions = []
    for day in meta.get("tradingPeriods") or []:
        for per in (day if isinstance(day, list) else [day]):
            if isinstance(per, dict) and per.get("start"):
                off = int(per.get("gmtoffset", gmtoff))
                sessions.append({"date": _local(per["start"], off, "%Y-%m-%d"), "open": _local(per["start"], off, "%H:%M"),
                                 "close": _local(per["end"], off, "%H:%M")})
    reg = (meta.get("currentTradingPeriod") or {}).get("regular") or {}
    info = {"currency": meta.get("currency"), "exchange": meta.get("fullExchangeName") or meta.get("exchangeName"),
            "timezone": meta.get("exchangeTimezoneName"), "instrument_type": meta.get("instrumentType"),
            "name": meta.get("longName") or meta.get("shortName"), "gmtoffset": gmtoff,
            "adjusted": daily, "source": "yahoo", "sessions": sessions,
            "previous_close": meta.get("chartPreviousClose") if interval == "1d" else meta.get("previousClose"),
            "last_price": meta.get("regularMarketPrice"),
            "market_time": _local(meta["regularMarketTime"], gmtoff) if meta.get("regularMarketTime") else None}
    if reg.get("start"):
        off = int(reg.get("gmtoffset", gmtoff))
        info["current_session"] = {"date": _local(reg["start"], off, "%Y-%m-%d"), "open": _local(reg["start"], off, "%H:%M"),
                                   "close": _local(reg["end"], off, "%H:%M")}
    return Bars.from_rows(symbol, interval, rows, info)


# ------------------------------------------------------------------ providers

class Provider:
    name = "base"

    def bars(self, symbol: str, interval: str = "1d", period: str = "2y",
             start: Optional[str] = None, end: Optional[str] = None) -> Bars:
        raise NotImplementedError

    def quote(self, symbol: str) -> Dict:
        b = self.bars(symbol, "1d", "5d")
        if not len(b):
            raise DataError(f"no data for {symbol}")
        last = b.last()
        prev = b.close[-2] if len(b) > 1 else last["close"]
        return {"symbol": symbol, "price": last["close"], "date": last["date"],
                "change_pct": round((last["close"] / prev - 1) * 100, 3) if prev else None,
                "source": self.name}


class YahooProvider(Provider):
    name = "yahoo"
    BASE = "https://query1.finance.yahoo.com/v8/finance/chart/"

    def bars(self, symbol, interval="1d", period="2y", start=None, end=None) -> Bars:
        if interval not in INTERVALS:
            raise DataError(f"interval must be one of {', '.join(INTERVALS)}")
        yint = "60m" if interval == "1h" else interval
        params: Dict = {"interval": yint, "includePrePost": "false", "events": "div,splits"}
        if start:
            s = dt.datetime.fromisoformat(start[:10]).replace(tzinfo=dt.timezone.utc)
            e = dt.datetime.fromisoformat(end[:10]).replace(tzinfo=dt.timezone.utc) + dt.timedelta(days=1) \
                if end else dt.datetime.now(dt.timezone.utc)
            params["period1"] = int(s.timestamp())
            params["period2"] = int(e.timestamp())
        else:
            if yint in _YAHOO_INTRADAY_MAX_DAYS:
                maxd = _YAHOO_INTRADAY_MAX_DAYS[yint]
                if period_days(period) > maxd:
                    period = {7: "5d", 60: "1mo", 730: "2y"}[maxd]
            params["range"] = period
        url = self.BASE + urllib.parse.quote(symbol)
        try:
            payload = http.get_json(url, params=params)
        except http.HTTPError as e:
            if e.status == 404:
                raise DataError(f"symbol not found on Yahoo: {symbol}") from None
            raise DataError(f"Yahoo request failed for {symbol}: {e}") from None
        bars = parse_yahoo_chart(payload, symbol, interval)
        if end and not start:
            bars = bars.until(end)
        return bars

    def quote(self, symbol: str) -> Dict:
        b = self.bars(symbol, "1d", "5d")
        if not len(b):
            raise DataError(f"no data for {symbol}")
        q = {
            "symbol": symbol, "price": b.close[-1], "date": b.date[-1],
            "change_pct": round((b.close[-1] / b.close[-2] - 1) * 100, 3) if len(b) > 1 else None,
            "source": self.name,
        }
        q["currency"] = b.meta.get("currency")
        q["delayed"] = True
        return q


class CSVProvider(Provider):
    name = "csv"

    def __init__(self, directory: Optional[str] = None):
        cfg = config.load()
        d = directory or cfg["data"].get("csv_dir")
        if not d:
            raise DataError("csv provider needs data.csv_dir (folder of SYMBOL.csv files). "
                            "Set it with: setup.py set data.csv_dir /path/to/folder")
        self.dir = Path(d).expanduser()

    def _file(self, symbol: str, interval: str) -> Path:
        safe = symbol.replace(":", "_").replace("/", "_")
        for cand in (f"{safe}_{interval}.csv", f"{safe}.csv", f"{safe.upper()}.csv", f"{safe.lower()}.csv"):
            p = self.dir / cand
            if p.exists():
                return p
        raise DataError(f"no CSV for {symbol} in {self.dir} (expected {safe}.csv)")

    def bars(self, symbol, interval="1d", period="2y", start=None, end=None) -> Bars:
        b = Bars.from_csv(self._file(symbol, interval), symbol=symbol, interval=interval)
        b.meta["source"] = "csv"
        if interval in ("1wk", "1mo") and not b.intraday and len(b) > 1:
            # if the file is daily, resample
            d0 = dt.date.fromisoformat(b.date[0][:10])
            d1 = dt.date.fromisoformat(b.date[1][:10])
            if (d1 - d0).days < 5:
                b = b.resample(interval)
        if start:
            b = b.since(start)
        elif period != "max" and len(b):
            cutoff = (dt.date.fromisoformat(b.date[-1][:10]) - dt.timedelta(days=period_days(period))).isoformat()
            b = b.since(cutoff)
        if end:
            b = b.until(end)
        return b


class KiteProvider(Provider):
    """Kite Connect historical candles. Requires the Connect (data) plan."""
    name = "kite"
    _INTERVALS = {"1m": "minute", "5m": "5minute", "15m": "15minute", "30m": "30minute",
                  "60m": "60minute", "1h": "60minute", "1d": "day"}
    _MAX_DAYS = {"minute": 60, "5minute": 100, "15minute": 200, "30minute": 200, "60minute": 400, "day": 2000}

    def __init__(self):
        from .brokers.kite import KiteClient
        self.client = KiteClient()

    def bars(self, symbol, interval="1d", period="2y", start=None, end=None) -> Bars:
        resample = None
        if interval in ("1wk", "1mo"):
            resample, interval = interval, "1d"
        if interval not in self._INTERVALS:
            raise DataError(f"kite supports intervals {', '.join(self._INTERVALS)}")
        kint = self._INTERVALS[interval]
        token = self.client.instrument_token(symbol)
        end_d = dt.datetime.fromisoformat(end[:10]) if end else dt.datetime.now()
        start_d = dt.datetime.fromisoformat(start[:10]) if start else end_d - dt.timedelta(days=period_days(period))
        rows: List[Dict] = []
        chunk = dt.timedelta(days=self._MAX_DAYS[kint])
        cur = start_d
        while cur < end_d:
            nxt = min(cur + chunk, end_d)
            data = self.client.historical(token, kint, cur.strftime("%Y-%m-%d %H:%M:%S"),
                                          nxt.strftime("%Y-%m-%d %H:%M:%S"))
            for c in data:
                rows.append({"date": normalize_date(c[0][:16].replace(" ", "T")) if kint != "day" else c[0][:10],
                             "open": c[1], "high": c[2], "low": c[3], "close": c[4], "volume": c[5]})
            cur = nxt + dt.timedelta(seconds=1)
        b = Bars.from_rows(symbol, interval, rows, {"source": "kite", "adjusted": False})
        return b.resample(resample) if resample else b

    def quote(self, symbol: str) -> Dict:
        q = self.client.ltp([symbol])
        item = q.get(symbol) or next(iter(q.values()), None)
        if not item:
            raise DataError(f"no quote for {symbol}")
        return {"symbol": symbol, "price": item["last_price"], "date": dt.datetime.now().isoformat(timespec="minutes"),
                "change_pct": None, "source": "kite", "delayed": False}


def get_provider(name: Optional[str] = None) -> Provider:
    name = (name or config.load()["data"]["provider"] or "yahoo").lower()
    if name == "yahoo":
        return YahooProvider()
    if name == "csv":
        return CSVProvider()
    if name == "kite":
        return KiteProvider()
    raise DataError(f"unknown data provider {name!r} (yahoo | csv | kite)")


# ------------------------------------------------------------------ cache + public API

def _cache_file(provider: str, symbol: str, interval: str, period: str, start, end) -> Path:
    safe = "".join(ch if ch.isalnum() or ch in "-_." else "_" for ch in symbol)
    tag = f"{period}" if not start else f"{start}_{end or 'now'}"
    return config.path("cache", provider, f"{safe}__{interval}__{tag}.csv")


def get_bars(symbol: str, interval: str = "1d", period: str = "2y", start: Optional[str] = None,
             end: Optional[str] = None, provider: Optional[str] = None, use_cache: bool = True,
             min_bars: int = 0) -> Bars:
    """Fetch bars through the configured provider, with a TTL file cache."""
    cfg = config.load()
    pname = (provider or cfg["data"]["provider"] or "yahoo").lower()
    ttl = float(cfg["data"].get("cache_ttl_minutes", 60)) * 60
    if pname == "csv":
        use_cache = False
    cf = _cache_file(pname, symbol, interval, period, start, end)
    meta_f = cf.with_suffix(".json")
    if use_cache and cf.exists() and (time.time() - cf.stat().st_mtime) < ttl:
        b = Bars.from_csv(cf, symbol=symbol, interval=interval)
        if meta_f.exists():
            try:
                b.meta = json.loads(meta_f.read_text())
            except json.JSONDecodeError:
                pass
    else:
        b = get_provider(pname).bars(symbol, interval, period, start, end)
        if use_cache and len(b):
            b.to_csv(cf)
            meta_f.write_text(json.dumps(b.meta))
    if len(b) < min_bars:
        raise DataError(f"{symbol}: only {len(b)} bars available, need at least {min_bars}")
    return b


def load_bars(symbol: Optional[str] = None, csv_path: Optional[str] = None, interval: str = "1d",
              period: str = "2y", provider: Optional[str] = None, min_bars: int = 0) -> Bars:
    """Bars from an explicit CSV file if given, else from the provider."""
    if csv_path:
        b = Bars.from_csv(Path(csv_path).expanduser(), symbol=symbol, interval=interval)
        b.meta.setdefault("source", "csv-file")
        if len(b) < min_bars:
            raise DataError(f"{b.symbol}: only {len(b)} bars in {csv_path}, need {min_bars}")
        return b
    if not symbol:
        raise DataError("give a symbol or --csv FILE")
    return get_bars(symbol, interval, period, provider=provider, min_bars=min_bars)


def add_data_args(p, period: str = "2y") -> None:
    """Standard data arguments for skill scripts."""
    p.add_argument("--interval", default="1d", choices=INTERVALS)
    p.add_argument("--period", default=period, choices=PERIODS)
    p.add_argument("--provider", choices=["yahoo", "csv", "kite"])
    p.add_argument("--csv", help="load bars from this CSV file instead of the provider")


def get_many(symbols: Sequence[str], interval: str = "1d", period: str = "2y", provider: Optional[str] = None,
             min_bars: int = 0, workers: int = 4, start: Optional[str] = None, end: Optional[str] = None):
    """Fetch many symbols concurrently. Returns (dict symbol->Bars, dict symbol->error)."""
    from concurrent.futures import ThreadPoolExecutor
    out: Dict[str, Bars] = {}
    errors: Dict[str, str] = {}

    def one(sym):
        try:
            return sym, get_bars(sym, interval, period, start=start, end=end, provider=provider, min_bars=min_bars), None
        except Exception as e:  # noqa: BLE001 - report per-symbol failures
            return sym, None, str(e)

    with ThreadPoolExecutor(max_workers=max(1, workers)) as ex:
        for sym, bars, err in ex.map(one, symbols):
            if err:
                errors[sym] = err
            else:
                out[sym] = bars
    return out, errors


def load_universe(spec: Optional[str] = None, symbols: Optional[Iterable[str]] = None) -> List[str]:
    """Symbols from a comma list, a text/CSV file (one per line or a 'symbol' column), or both."""
    syms: List[str] = []
    if spec:
        p = Path(spec).expanduser()
        if p.exists():
            text = p.read_text()
            lines = [ln.strip() for ln in text.splitlines() if ln.strip() and not ln.strip().startswith("#")]
            if lines and "," in lines[0]:
                header = [h.strip().lower() for h in lines[0].split(",")]
                col = next((i for i, h in enumerate(header) if h in ("symbol", "ticker", "tradingsymbol")), 0)
                start = 1 if header[col] in ("symbol", "ticker", "tradingsymbol") else 0
                syms += [ln.split(",")[col].strip() for ln in lines[start:]]
            else:
                syms += [ln.split()[0] for ln in lines]
        else:
            syms += [s.strip() for s in spec.split(",") if s.strip()]
    if symbols:
        syms += [s.strip() for s in symbols if s and s.strip()]
    seen = set()
    out = []
    for s in syms:
        if s not in seen:
            seen.add(s)
            out.append(s)
    return out


def fresh_bars(symbol: str, interval: str = "5m", period: str = "1d", provider: Optional[str] = None,
               offline: Optional[str] = None) -> Bars:
    """Bars straight from the source, never from the cache (prices that must be current).

    offline: a saved Yahoo chart JSON file, or a folder holding chart-<SYMBOL>-<interval>.json
    (used by tests and to replay a past session)."""
    if offline:
        p = Path(offline).expanduser()
        if p.is_dir():
            p = p / f"chart-{symbol}-{interval}.json"
        if not p.exists():
            raise DataError(f"no saved chart for {symbol} at {p}")
        text = p.read_bytes()
        if p.suffix == ".gz":
            import gzip
            text = gzip.decompress(text)
        return parse_yahoo_chart(json.loads(text.decode("utf-8")), symbol, interval)
    return get_provider(provider).bars(symbol, interval, period)


def live_quote(symbol: str, provider: Optional[str] = None, offline: Optional[str] = None) -> Dict:
    """Price, previous close, exchange session and status for one symbol (delayed on free data)."""
    from . import session as _session
    b = fresh_bars(symbol, "5m", "5d", provider, offline)
    if not len(b):
        raise DataError(f"no intraday data for {symbol}")
    price = b.meta.get("last_price") or b.close[-1]
    # previous close = last bar of the session before the latest one (Yahoo's meta field is unreliable after hours)
    last_day = b.date[-1][:10]
    before = [i for i, d in enumerate(b.date) if d[:10] < last_day]
    prev = b.close[before[-1]] if before else b.meta.get("previous_close")
    return {"symbol": symbol, "price": float(price), "previous_close": prev,
            "name": b.meta.get("name"), "currency": b.meta.get("currency"), "exchange": b.meta.get("exchange"),
            "timezone": b.meta.get("timezone"), "market_time": b.meta.get("market_time") or b.date[-1],
            "gmtoffset": b.meta.get("gmtoffset"), "bars": b, "source": b.meta.get("source", "yahoo"),
            "delayed": b.meta.get("source", "yahoo") == "yahoo"}
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