11 Claude skills for day trading: scan thousands of charts, track breaking news, time every entry and exit, and replay every outcome before you risk a dollar.
#!/usr/bin/env python3
"""Entry Timer for trader-entry: watches a setup bar by bar and says the
moment to get in. Standard library only. Long side only. It never places an order.
python3 entry.py check TSLA # opening-range breakout, 5-minute bars
python3 entry.py check TSLA --now "2026-10-19 10:15" --offline TSLA.json
python3 entry.py check TSLA --setup level --level 371.20 # first close above a price
python3 entry.py check TSLA --interval 1m --min-volume-x 1.5 --write
python3 entry.py watch TSLA --every 30 --until 15:30 # one line per closed bar
python3 entry.py watchlist # every hit in trader/watchlist.json
Setups (v2 plans longs only):
orb opening-range breakout. The range is the high and low of the first
--or-minutes (default 15: the 9:30, 9:35 and 9:40 five-minute bars).
It triggers on the first COMPLETED bar after the range that CLOSES
above the range high. A wick above the high is not a trigger.
level the first completed bar that closes above --level (for example a
20-day high from trader-scanner).
--min-volume-x X the trigger bar also needs at least X times the average
volume of the opening-range bars (the 9:30 bar carries the opening
auction, so 1.0 is already a high bar).
A trigger's time is the trigger bar's CLOSE time (the 10:10 bar closes at
10:15 AM) and its price is that close, to the cent. Only bars on the interval
grid count (Yahoo's live tick, e.g. 10:49:45, is dropped) and a bar counts only
once it has closed: now >= its start + the interval.
Statuses: triggered; waiting (not open yet, range still forming, or no close
above the level yet); expired (no trigger by no_entries_after, default 15:30;
on a 1:00 p.m. early close the cutoff moves up three hours with the close);
no-data (the market is closed today or Yahoo sent no bars).
trader/config.json (optional): "no_entries_before" (09:45) and
"no_entries_after" (15:30), New York time.
watch wakes just after each bar closes (bars only change then), re-polls every
--every seconds (default 30) while Yahoo has not posted the new bar, prints one
line per closed bar and stops on a trigger (exit 0, writes trader/entry.json),
on expiry, at the close or at --until (exit 1). With --now or --offline it runs
on a simulated clock and replays the day without sleeping.
Data: Yahoo's free chart JSON (unofficial, can lag, bars not single trades)
https://query2.finance.yahoo.com/v8/finance/chart/TSLA?range=1d&interval=5m
falls back to query1 on HTTP 429 or 5xx; a 429 gets one retry after a pause.
--offline PATH reads a saved chart JSON (.json or .json.gz) instead, or
PATH/<TICKER>.json when PATH is a folder. Without --now, an offline file is
read as of its own time (meta.regularMarketTime).
Exit codes: check 0 = triggered, 1 = anything else or an error. watch 0 on a
trigger, 1 otherwise. watchlist 0 when at least one symbol triggered.
"""
import argparse
import datetime
import gzip
import json
import os
import re
import sys
import time
import urllib.error
import urllib.request
UA = "Mozilla/5.0 (compatible; day-trader-skill/2.0; +https://github.com/Jakeschincariol/day-trader-skill)"
PAUSE = 0.5 # seconds between requests to the free endpoint
BACKOFF = 5.0 # seconds before the one retry after an HTTP 429
GRACE = 2 # seconds after a bar closes before watch asks for it
SETTLE = 60 # seconds a closed bar may wait for Yahoo's data to catch up
HOSTS = ("query2", "query1")
INTERVALS = {"1m": 60, "5m": 300}
DEFAULTS = {"no_entries_before": "09:45", "no_entries_after": "15:30"}
EPOCH = datetime.datetime(1970, 1, 1)
NYSE_HOLIDAYS = {
"2026-01-01": "New Year's Day",
"2026-01-19": "Martin Luther King, Jr. Day",
"2026-02-16": "Washington's Birthday",
"2026-04-03": "Good Friday",
"2026-05-25": "Memorial Day",
"2026-06-19": "Juneteenth National Independence Day",
"2026-07-03": "Independence Day (observed)",
"2026-09-07": "Labor Day",
"2026-11-26": "Thanksgiving Day",
"2026-12-25": "Christmas Day",
"2027-01-01": "New Year's Day",
"2027-01-18": "Martin Luther King, Jr. Day",
"2027-02-15": "Washington's Birthday",
"2027-03-26": "Good Friday",
"2027-05-31": "Memorial Day",
"2027-06-18": "Juneteenth National Independence Day (observed)",
"2027-07-05": "Independence Day (observed)",
"2027-09-06": "Labor Day",
"2027-11-25": "Thanksgiving Day",
"2027-12-24": "Christmas Day (observed)",
}
NYSE_EARLY_CLOSE = { # 1:00 p.m. ET
"2026-11-27": "day after Thanksgiving",
"2026-12-24": "Christmas Eve",
"2027-11-26": "day after Thanksgiving",
}
CALENDAR_YEARS = (2026, 2027)
OPEN = datetime.time(9, 30)
CLOSE = datetime.time(16, 0)
EARLY = datetime.time(13, 0)
class EntryError(Exception):
pass
# ---------------------------------------------------------------- time
def _nth_sunday(year, month, n):
d = datetime.date(year, month, 1)
d += datetime.timedelta(days=(6 - d.weekday()) % 7)
return d + datetime.timedelta(weeks=n - 1)
def eastern_offset(utc):
"""Hours from UTC for New York: -4 in daylight time, -5 otherwise.
DST runs from 2:00 a.m. on the second Sunday of March to 2:00 a.m. on the
first Sunday of November (US rule since 2007)."""
y = utc.year
start = datetime.datetime.combine(_nth_sunday(y, 3, 2), datetime.time(7, 0)) # 2:00 EST
end = datetime.datetime.combine(_nth_sunday(y, 11, 1), datetime.time(6, 0)) # 2:00 EDT
naive = utc.replace(tzinfo=None)
return -4 if start <= naive < end else -5
def to_eastern(utc):
return utc.replace(tzinfo=None) + datetime.timedelta(hours=eastern_offset(utc))
def eastern_to_utc(local):
for off in (-4, -5):
utc = local - datetime.timedelta(hours=off)
if eastern_offset(utc) == off:
return utc
return local + datetime.timedelta(hours=5)
def utc_now():
return datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0, tzinfo=None)
def utc_of(ts):
"""Unix seconds -> naive UTC, without the machine's time zone."""
return EPOCH + datetime.timedelta(seconds=int(ts))
def ts_of(utc):
return int((utc.replace(tzinfo=None) - EPOCH).total_seconds())
def iso(utc):
return utc.strftime("%Y-%m-%dT%H:%M:%SZ")
def parse_now(text):
"""--now -> naive UTC. "2026-10-19 10:15" (or ...T10:15, or just 10:15 for
today) is New York time; an offset or Z makes it absolute."""
if not text:
return utc_now()
t = text.strip()
if t.upper().endswith(" ET"):
t = t[:-3].strip()
if re.match(r"^\d{1,2}:\d{2}$", t):
t = "%s %s" % (to_eastern(utc_now()).date().isoformat(), t.zfill(5))
t = t.replace("Z", "+00:00")
try:
dt = datetime.datetime.fromisoformat(t)
except ValueError:
raise EntryError('--now wants a New York time like "2026-10-19 10:15" (or ...Z for UTC)')
if dt.tzinfo is None:
return eastern_to_utc(dt)
return (dt - dt.utcoffset()).replace(tzinfo=None)
def parse_hhmm(text, what):
m = re.match(r"^\s*(\d{1,2}):(\d{2})\s*$", str(text))
if not m or int(m.group(1)) > 23 or int(m.group(2)) > 59:
raise EntryError("%s wants a New York time like 15:30, not %r" % (what, text))
return datetime.time(int(m.group(1)), int(m.group(2)))
def hm(t):
"""10:10, 09:45: the contract's wall-clock form."""
return "%02d:%02d" % (t.hour, t.minute)
def short(t):
"""9:45, 10:10: for sentences."""
return "%d:%02d" % (t.hour, t.minute)
def ampm(t):
h = t.hour % 12 or 12
return "%d:%02d %s" % (h, t.minute, "AM" if t.hour < 12 else "PM")
def trading_day(d):
"""(is_trading_day, reason). Weekends and the NYSE holiday list."""
if d.weekday() >= 5:
return False, "weekend"
name = NYSE_HOLIDAYS.get(d.isoformat())
if name:
return False, "NYSE holiday: " + name
return True, ""
def session(d):
"""(open_time, close_time) in New York time, or None if closed all day."""
ok, _ = trading_day(d)
if not ok:
return None
return OPEN, (EARLY if d.isoformat() in NYSE_EARLY_CLOSE else CLOSE)
def next_open(d):
nd = d + datetime.timedelta(days=1)
for _ in range(15):
if session(nd):
return "%s 09:30" % nd.isoformat()
nd += datetime.timedelta(days=1)
return None
# ---------------------------------------------------------------- Yahoo
def yahoo_symbol(sym):
return sym.upper().replace(".", "-")
def chart_path(sym, rng, interval):
return "/v8/finance/chart/%s?range=%s&interval=%s" % (yahoo_symbol(sym), rng, interval)
def chart_range(day, today, interval):
"""The smallest Yahoo range that still holds the session of `day`."""
back = (today - day).days
if back <= 0:
return "1d"
if back <= 6:
return "5d"
if interval == "1m":
raise EntryError("Yahoo keeps 1-minute bars for about a week: use --interval 5m for %s" % day)
if back <= 28:
return "1mo"
if back <= 58:
return "60d"
raise EntryError("Yahoo keeps 5-minute bars for about 60 days: %s is too far back" % day)
def _open_url(url, timeout=20):
req = urllib.request.Request(url, headers={"User-Agent": UA, "Accept": "application/json"})
with urllib.request.urlopen(req, timeout=timeout) as r:
return r.read().decode("utf-8", "replace")
def _sleep(seconds):
time.sleep(seconds)
def yahoo_get(path):
"""GET a Yahoo path: query2 first, query1 when query2 answers 429 or 5xx.
An HTTP 429 gets one retry on the same host after BACKOFF seconds."""
last = "no answer"
for host in HOSTS:
url = "https://%s.finance.yahoo.com%s" % (host, path)
for attempt in (0, 1):
try:
return _open_url(url)
except urllib.error.HTTPError as e:
code, body = e.code, None
try:
if code == 404: # Yahoo says why in the body: an unknown ticker
body = e.read().decode("utf-8", "replace")
except Exception:
body = None
finally:
e.close()
if code == 404:
if body:
return body
raise EntryError("Yahoo has no chart at %s (HTTP 404)" % url.split("?")[0])
last = "HTTP %d" % code
if code == 429 and attempt == 0:
_sleep(BACKOFF)
continue
if code == 429 or code >= 500:
break
raise EntryError("Yahoo answered HTTP %d for %s" % (code, url.split("?")[0]))
except urllib.error.URLError as e:
last = "could not connect: %s" % (e.reason,)
break
except OSError as e:
last = "network error: %s" % (e,)
break
raise EntryError("Yahoo did not answer (%s on query2 and query1): wait a minute and try again" % last)
def parse_chart(text, sym):
"""Yahoo chart JSON v8 -> {symbol, meta, bars, prev_close, data_time}.
Bars with a null close are dropped here; off-grid ticks later."""
try:
data = json.loads(text)
res = data["chart"]["result"]
except (ValueError, KeyError, TypeError):
raise EntryError("Yahoo returned something unexpected for %s" % sym)
if not res:
err = (data.get("chart") or {}).get("error") or {}
raise EntryError("Yahoo has no data for %s: %s" % (sym, err.get("description") or "unknown ticker"))
r = res[0] or {}
meta = r.get("meta") or {}
q = ((r.get("indicators") or {}).get("quote") or [{}])[0] or {}
def at(key, i):
arr = q.get(key) or []
return arr[i] if i < len(arr) else None
bars = []
for i, t in enumerate(r.get("timestamp") or []):
c = at("close", i)
if t is None or c is None:
continue
o, h, lo = at("open", i), at("high", i), at("low", i)
bars.append({"t": int(t), "o": float(c if o is None else o), "h": float(c if h is None else h),
"l": float(c if lo is None else lo), "c": float(c), "v": int(at("volume", i) or 0)})
return {"symbol": str(meta.get("symbol") or sym).upper(), "meta": meta, "bars": bars,
"prev_close": meta.get("previousClose") or meta.get("chartPreviousClose"),
"data_time": meta.get("regularMarketTime")}
def read_text(path):
if path.endswith(".gz"):
with gzip.open(path, "rt", encoding="utf-8") as fh:
return fh.read()
with open(path, encoding="utf-8") as fh:
return fh.read()
def offline_file(path, sym):
if os.path.isdir(path):
for name in (sym + ".json", sym + ".json.gz", yahoo_symbol(sym) + ".json", yahoo_symbol(sym) + ".json.gz"):
p = os.path.join(path, name)
if os.path.exists(p):
return p
raise EntryError("no offline file for %s in %s (want %s.json)" % (sym, path, sym))
if not os.path.exists(path):
raise EntryError("no offline file %s" % path)
return path
def get_chart(sym, interval, day=None, offline=None, today=None):
"""Bars for one ticker, from Yahoo (range=1d for today) or a saved file."""
sym = sym.upper()
if offline:
f = offline_file(offline, sym)
try:
text = read_text(f)
except (OSError, ValueError) as e:
raise EntryError("could not read %s: %s" % (f, e))
else:
today = today or to_eastern(utc_now()).date()
text = yahoo_get(chart_path(sym, chart_range(day or today, today, interval), interval))
ch = parse_chart(text, sym)
if ch["symbol"] != yahoo_symbol(sym):
raise EntryError("the chart file holds %s, not %s" % (ch["symbol"], sym))
gran = ch["meta"].get("dataGranularity")
if gran and gran != interval:
raise EntryError("%s has %s bars, not %s: use --interval %s" % (sym, gran, interval, gran))
return ch
# ---------------------------------------------------------------- the rule
def read_config(path):
cfg = dict(DEFAULTS)
if path and os.path.exists(path):
try:
with open(path, encoding="utf-8") as fh:
doc = json.load(fh)
except ValueError as e:
raise EntryError("%s is not valid JSON: %s" % (path, e))
for k in DEFAULTS:
if doc.get(k):
cfg[k] = doc[k]
for k in DEFAULTS:
parse_hhmm(cfg[k], k)
return cfg
def r2(x):
return None if x is None else round(float(x), 2) + 0.0 # + 0.0 turns -0.0 into 0.0
def early_cutoff(day, t, close_dt):
"""A cutoff on an early-close day moves up with the close: 15:30 (30 minutes
before a 16:00 close) becomes 12:30 before a 1:00 p.m. close. A cutoff that
is already before the early close stays."""
at = datetime.datetime.combine(day, t)
if at < close_dt:
return at
moved = at - (datetime.datetime.combine(day, CLOSE) - close_dt)
return moved if moved.time() > OPEN else close_dt
def evaluate(chart, now_utc, setup="orb", or_minutes=15, interval="5m", level=None,
min_volume_x=None, cfg=None):
"""Pure function: the setup's status at now_utc from one session's bars."""
cfg = cfg or dict(DEFAULTS)
if interval not in INTERVALS:
raise EntryError("--interval is 5m or 1m")
step = INTERVALS[interval]
if or_minutes <= 0 or (or_minutes * 60) % step:
raise EntryError("--or-minutes must be a whole number of %s bars" % interval)
if setup not in ("orb", "level"):
raise EntryError("--setup is orb or level")
if setup == "level" and level is None:
raise EntryError("--setup level needs --level PRICE (for example a 20-day high)")
n_or = or_minutes * 60 // step
local = to_eastern(now_utc)
day = local.date()
res = {"symbol": chart["symbol"], "setup": setup, "side": "buy", "date": day.isoformat(),
"interval": interval, "or_minutes": or_minutes, "now": local.strftime("%Y-%m-%d %H:%M:%S"), "status": "waiting",
"phase": "", "reason": "", "opening_range": None, "level": None, "trigger": None,
"last": None, "forming": None, "min_volume_x": min_volume_x,
"prev_close": chart.get("prev_close"), "calendar_known": day.year in CALENDAR_YEARS, "_bars": []}
dt = chart.get("data_time")
res["data_time"] = to_eastern(utc_of(dt)).strftime("%Y-%m-%d %H:%M:%S") if dt else None
ok, why = trading_day(day)
if not ok:
res.update(status="no-data", phase="closed", reason="the NYSE is closed today (%s)" % why,
next_open=next_open(day))
return res
o, c = session(day)
open_dt = datetime.datetime.combine(day, o)
close_dt = datetime.datetime.combine(day, c)
early = c != CLOSE
before = datetime.datetime.combine(day, parse_hhmm(cfg["no_entries_before"], "no_entries_before"))
cutoff = early_cutoff(day, parse_hhmm(cfg["no_entries_after"], "no_entries_after"), close_dt)
or_end = open_dt + datetime.timedelta(minutes=or_minutes)
res.update(opens=hm(o), closes=hm(c), early_close=NYSE_EARLY_CLOSE.get(day.isoformat()),
no_entries_before=hm(before), no_entries_after=hm(cutoff))
by_slot = {}
for b in chart["bars"]:
if b["t"] % step:
continue # Yahoo's live tick (10:49:45) is not a bar
et = to_eastern(utc_of(b["t"]))
if et.date() != day or not (open_dt <= et < close_dt):
continue
slot = int((et - open_dt).total_seconds()) // step
by_slot[slot] = dict(b, et=et, end=et + datetime.timedelta(seconds=step), slot=slot)
bars, pending = [], None
now_ts = ts_of(now_utc)
top = max(by_slot) if by_slot else -1
for slot in sorted(by_slot):
b = by_slot[slot]
end_ts = b["t"] + step
if end_ts <= now_ts:
# Closed by the clock. On live data it counts once Yahoo has caught up: its last
# trade is at or after the close, a later bar exists, or a minute has passed.
if dt is None or dt >= end_ts or slot < top or now_ts >= end_ts + SETTLE:
bars.append(b)
else:
pending = b
res["forming"] = {"bar_start": hm(b["et"]), "closes": ampm(b["end"]), "price": r2(b["c"])}
res["lag_note"] = ("Yahoo's last trade is %s, before the %s bar's close: it counts once Yahoo "
"catches up (a minute at most)" % (to_eastern(utc_of(dt)).strftime("%H:%M:%S"),
short(b["et"])))
elif b["et"] <= local:
res["forming"] = {"bar_start": hm(b["et"]), "closes": ampm(b["end"]), "price": r2(b["c"])}
res["_bars"] = bars
res["bars_closed"] = len(bars)
if local < open_dt:
res.update(phase="pre-open", reason="the NYSE opens at 9:30%s" % (
" and the %d-minute range is set at %s" % (or_minutes, short(or_end)) if setup == "orb" else ""))
return res
or_bars = [b for b in bars if b["slot"] < n_or]
avg_vol = (sum(b["v"] for b in or_bars) / float(len(or_bars))) if or_bars else None
if or_bars:
res["opening_range"] = {"high": r2(max(b["h"] for b in or_bars)), "low": r2(min(b["l"] for b in or_bars)),
"minutes": or_minutes, "bars": len(or_bars), "of": n_or,
"complete": local >= or_end, "avg_volume": int(round(avg_vol))}
if setup == "orb":
if local < or_end:
res.update(phase="forming", reason="%d of %d range bars closed; the range is set at %s" % (
len(or_bars), n_or, short(or_end)))
return res
if not or_bars:
res.update(status="no-data", phase="open", reason="Yahoo sent no bars for the opening range")
return res
lvl = max(b["h"] for b in or_bars)
else:
lvl = float(level)
res["level"] = r2(lvl)
first_slot = n_or if setup == "orb" else 0
trig, thin = None, []
for b in bars:
if b["slot"] < first_slot or b["end"] < before or b["end"] > cutoff:
continue
if b["c"] > lvl:
vx = (b["v"] / avg_vol) if avg_vol else None
if min_volume_x and (vx is None or vx < min_volume_x):
thin.append(b)
continue
trig = b
break
last = bars[-1] if bars else None
if last:
res["last"] = {"bar_start": hm(last["et"]), "close": r2(last["c"]),
"vs_level_pct": r2(100.0 * (last["c"] / lvl - 1))}
if trig:
vx = (trig["v"] / avg_vol) if avg_vol else None
res.update(status="triggered", phase="open" if local < close_dt else "after-close",
reason="the %s bar closed above %s" % (short(trig["et"]), "the range high" if setup == "orb" else "the level"))
res["trigger"] = {"time": ampm(trig["end"]), "close_time": hm(trig["end"]), "bar_start": hm(trig["et"]),
"bar_index": trig["slot"], "price": r2(trig["c"]), "close": trig["c"],
"volume": trig["v"], "volume_x": r2(vx), "pct_over": r2(100.0 * (trig["c"] / lvl - 1))}
res["minutes_since"] = int((local - trig["end"]).total_seconds() // 60)
if dt and utc_of(dt) < eastern_to_utc(trig["end"]):
res["data_note"] = ("Yahoo's last trade is %s, before this bar closed: its close can still move a cent or two"
% to_eastern(utc_of(dt)).strftime("%H:%M:%S"))
return res
if not bars:
res.update(status="no-data", phase="open", reason="Yahoo sent no bars for %s yet" % day.isoformat())
return res
what = "close above the range high $%.2f" % lvl if setup == "orb" else "close above $%.2f" % lvl
if local >= cutoff and not (pending and pending["end"] <= cutoff):
res.update(status="expired", phase="after-close" if local >= close_dt else "after-cutoff",
reason="no %s by %s, the last time for a new entry%s" % (
what, short(cutoff), " (1:00 p.m. early close today)" if early else ""))
return res
res["phase"] = "open"
if last["c"] > lvl and last in thin:
res["reason"] = "the %s bar closed above at $%.2f but on %.2fx the range's volume, under your %.2fx" % (
short(last["et"]), last["c"], last["v"] / avg_vol if avg_vol else 0, min_volume_x)
elif last["c"] > lvl and last["end"] < before:
res["reason"] = "the %s bar closed above at $%.2f, but no entries before %s (config)" % (
short(last["et"]), last["c"], short(before))
else:
gap = lvl - last["c"]
res["reason"] = "last close $%.2f (%s bar), $%.2f %s %s (%+.2f%%)" % (
last["c"], short(last["et"]), abs(gap), "under" if gap >= 0 else "over",
"the range high $%.2f" % lvl if setup == "orb" else "the level $%.2f" % lvl,
100.0 * (last["c"] / lvl - 1))
return res
def public(res):
"""The result without the internal bar list, ready for JSON."""
return {k: v for k, v in res.items() if not k.startswith("_")}
def entry_doc(res, now_utc):
"""trader/entry.json, the contract shape (plus a plain-words reason)."""
t = res.get("trigger") or {}
orr = res.get("opening_range")
return {"created_by": "trader-entry", "symbol": res["symbol"], "setup": res["setup"], "side": "buy",
"date": res["date"], "status": res["status"], "time": t.get("time"), "bar_start": t.get("bar_start"),
"bar_index": t.get("bar_index"), "price": t.get("price"), "level": res.get("level"),
"interval": res["interval"],
"opening_range": {"high": orr["high"], "low": orr["low"], "minutes": orr["minutes"]} if orr else None,
"source": "yahoo", "checked_at": iso(now_utc), "reason": res.get("reason")}
def write_json(path, doc):
d = os.path.dirname(path)
if d:
os.makedirs(d, exist_ok=True)
with open(path, "w", encoding="utf-8") as fh:
json.dump(doc, fh, indent=2)
fh.write("\n")
# ---------------------------------------------------------------- words
LABEL = {"triggered": "TRIGGERED", "waiting": "WAITING", "expired": "EXPIRED", "no-data": "NO DATA"}
PHASE_LABEL = {"pre-open": "NOT OPEN YET", "forming": "RANGE FORMING", "closed": "MARKET CLOSED"}
SHORT = {"pre-open": "not open", "forming": "forming", "closed": "closed"}
def setup_name(res):
if res["setup"] == "orb":
return "opening-range breakout (%d-minute range)" % res["or_minutes"]
return "close above $%.2f" % res["level"] if res["level"] is not None else "close above a level"
def describe(res):
"""Plain lines for a person."""
when = datetime.datetime.strptime(res["now"], "%Y-%m-%d %H:%M:%S")
bars = "5-minute" if res["interval"] == "5m" else "1-minute"
head = "%s %s %s ET %s on %s bars (Yahoo, free, can lag)" % (
res["symbol"], when.strftime("%a %Y-%m-%d"), when.strftime("%H:%M"), setup_name(res), bars)
if res.get("data_time") and res["data_time"] <= res["now"] and res["data_time"][:10] == res["date"]:
head += ", data to %s" % res["data_time"][11:]
out = [head]
orr = res.get("opening_range")
if orr:
start = datetime.datetime.strptime(res["opens"], "%H:%M")
end = start + datetime.timedelta(minutes=orr["minutes"])
out.append("Opening range %s-%s: high $%.2f, low $%.2f (%d of %d bars%s)." % (
short(start), short(end), orr["high"], orr["low"], orr["bars"], orr["of"],
"" if orr["complete"] else ", still forming"))
label = PHASE_LABEL.get(res["phase"]) or LABEL.get(res["status"], res["status"].upper())
t = res.get("trigger")
if t:
out.append("TRIGGERED %s at $%.2f: the %s bar (bar %d) closed above %s $%.2f (%+.2f%%%s)." % (
t["time"], t["price"], short(datetime.datetime.strptime(t["bar_start"], "%H:%M")), t["bar_index"],
"the range high" if res["setup"] == "orb" else "the level", res["level"], t["pct_over"],
(", %.2fx the range's volume" % t["volume_x"]) if res.get("min_volume_x") and t.get("volume_x") else ""))
step = INTERVALS[res["interval"]] // 60
if res.get("minutes_since", 0) > step and res.get("last"):
out.append("That was %d minutes ago; the last close is $%.2f (%s bar). A late entry is a different "
"trade: the price, the stop distance and the odds have moved." % (
res["minutes_since"], res["last"]["close"], res["last"]["bar_start"]))
if res.get("data_note"):
out.append(res["data_note"] + ".")
if res.get("minutes_since", 0) > step:
out.append("Nothing was placed.")
else:
out.append("This is the moment to get in, if you take the trade. Nothing was placed.")
out.append("Next: set the stop and target BEFORE you buy: /trader-exit "
"(exit.py plan --from trader/entry.json).")
else:
out.append("%s %s." % (label, res["reason"]))
f = res.get("forming")
if res.get("lag_note") and res["status"] == "waiting":
out.append(res["lag_note"] + ".")
elif f and res["status"] == "waiting" and res["phase"] in ("open", "forming"):
out.append("The %s bar is still forming ($%.2f so far, closes %s); it does not count until it closes." % (
f["bar_start"].lstrip("0"), f["price"], f["closes"]))
if res["status"] == "expired":
out.append("No entry on this setup today. Nothing was placed.")
if res.get("next_open"):
out.append("Next open: %s New York." % res["next_open"])
if res.get("early_close"):
out.append("Early close today at 1:00 p.m. (%s): no new entries after %s." % (
res["early_close"], res["no_entries_after"]))
if not res.get("calendar_known"):
out.append("Holiday list covers %s only: check nyse.com for this date." % " and ".join(map(str, CALENDAR_YEARS)))
return out
def bar_line(b, res):
"""One watch line for a bar that just closed."""
start = short(b["et"])
orr = res.get("opening_range") or {}
lvl = res.get("level")
t = res.get("trigger")
n_or = orr.get("of") or 0
if res["setup"] == "orb" and b["slot"] < n_or:
seen = [x for x in res["_bars"] if x["slot"] <= b["slot"]]
note = "range so far $%.2f to $%.2f" % (min(x["l"] for x in seen), max(x["h"] for x in seen))
if b["slot"] == n_or - 1:
note = "opening range set: high $%.2f, low $%.2f" % (orr["high"], orr["low"])
elif t and t["bar_index"] == b["slot"]:
note = "TRIGGERED: closed above $%.2f (%+.2f%%). Get in now if you take it: %s, $%.2f" % (
lvl, t["pct_over"], t["time"], t["price"])
elif lvl is None:
note = ""
elif b["c"] > lvl:
note = "above $%.2f" % lvl
if res["setup"] == "level" or b["slot"] >= n_or:
avg = orr.get("avg_volume")
if res.get("min_volume_x") and avg:
note += ", but volume %.2fx is under %.2fx" % (b["v"] / float(avg), res["min_volume_x"])
elif b["end"] < datetime.datetime.combine(b["et"].date(), parse_hhmm(res["no_entries_before"], "x")):
note += ", but no entries before %s" % res["no_entries_before"]
else:
note = "$%.2f under $%.2f" % (lvl - b["c"], lvl)
return "%5s bar closed $%.2f %s" % (start, b["c"], note)
# ---------------------------------------------------------------- watch
class SimClock(object):
"""A clock that moves only when it sleeps: replays a day without waiting."""
def __init__(self, start):
self.t = start
def now(self):
return self.t
def sleep(self, seconds):
self.t += datetime.timedelta(seconds=max(1, int(round(seconds))))
def watch_loop(provider, clock, sleep, emit, opts, every=30, until=None, max_errors=5, on_trigger=None):
"""Poll bar by bar until a trigger (0), expiry, the close or --until (1).
provider(now_utc) -> chart, clock() -> naive UTC, sleep(seconds), emit(line).
It sleeps in steps of at most `every` seconds and re-reads the clock each time,
so a computer that dozed off catches up as soon as it wakes."""
step = INTERVALS[opts.get("interval", "5m")]
printed, errors, said_preopen, first = -1, 0, False, True
next_fetch = None
while True:
now = clock()
if next_fetch is not None and now < next_fetch:
sleep(max(1, min(every, (next_fetch - now).total_seconds())))
continue
local = to_eastern(now)
day = local.date()
s = session(day)
if not s:
emit("%s: market closed today (%s). Nothing to watch." % (day.isoformat(), trading_day(day)[1]))
return 1, None
open_dt = datetime.datetime.combine(day, s[0])
close_dt = datetime.datetime.combine(day, s[1])
if local < open_dt + datetime.timedelta(seconds=step):
if not said_preopen:
emit("%s ET %s: watching from the first bar's close at %s." % (
local.strftime("%H:%M"), "not open yet" if local < open_dt else "open, no bar closed yet",
short(open_dt + datetime.timedelta(seconds=step))))
said_preopen = True
next_fetch = eastern_to_utc(open_dt) + datetime.timedelta(seconds=step + GRACE)
continue
try:
chart = provider(now)
errors = 0
except EntryError as e:
errors += 1
emit("%s ET could not read bars: %s" % (local.strftime("%H:%M:%S"), e))
if errors >= max_errors:
emit("Stopping after %d failed reads in a row." % errors)
return 1, None
next_fetch = now + datetime.timedelta(seconds=every)
continue
res = evaluate(chart, now, **opts)
bars = res["_bars"]
lines = describe(res)
fresh = first
if first:
emit(lines[0])
if len(lines) > 1 and lines[1].startswith("Opening range"):
emit(lines[1])
if bars and not res.get("trigger"):
emit(bar_line(bars[-1], res))
printed = bars[-1]["slot"] if bars else -1
first = False
else:
for b in bars:
if b["slot"] > printed:
emit(bar_line(b, res))
printed = b["slot"]
if res["status"] == "triggered":
for line in lines[1:]:
if line.startswith("Opening range") or (line.startswith("TRIGGERED") and not fresh):
continue
emit(line)
if on_trigger:
on_trigger(res, now)
return 0, res
if res["status"] == "expired" or local >= close_dt:
emit("EXPIRED %s." % (res["reason"] or "the market closed without a trigger"))
return 1, res
if until and local >= until:
emit("Stopped at --until %s without a trigger. %s." % (short(until), res["reason"]))
return 1, res
# sleep until just after the next bar closes; poll every `every` seconds if Yahoo is behind
cur_slot = int((local - open_dt).total_seconds()) // step
expected_last = cur_slot - 1
behind = (not bars) or bars[-1]["slot"] < expected_last
if behind:
wait = every
else:
nxt = open_dt + datetime.timedelta(seconds=(cur_slot + 1) * step + GRACE)
wait = (nxt - local).total_seconds()
cutoff = datetime.datetime.combine(day, parse_hhmm(res.get("no_entries_after") or "15:30", "cutoff"))
for stop_at in (until, cutoff, close_dt):
if stop_at and stop_at > local:
wait = min(wait, (stop_at - local).total_seconds())
next_fetch = now + datetime.timedelta(seconds=max(1, wait))
# ---------------------------------------------------------------- commands
def _opts(a, cfg):
if a.side in ("sell", "short"):
raise EntryError("v2 plans longs only: no short entries. Watch for a buy (--side buy) instead.")
if a.setup == "orb" and a.level is not None:
raise EntryError("--level is for --setup level (an orb's level is its range high)")
if a.min_volume_x is not None and a.min_volume_x <= 0:
raise EntryError("--min-volume-x must be above 0")
if a.level is not None and a.level <= 0:
raise EntryError("--level must be a price above 0")
return {"setup": a.setup, "or_minutes": a.or_minutes, "interval": a.interval, "level": a.level,
"min_volume_x": a.min_volume_x, "cfg": cfg}
def _load(a, sym, now):
"""(chart, now). An offline file without --now is read as of its own time."""
real_today = to_eastern(utc_now()).date()
if a.offline and now is None:
ch = get_chart(sym, a.interval, offline=a.offline)
return ch, (utc_of(ch["data_time"]) if ch.get("data_time") else utc_now())
now = now or utc_now()
return get_chart(sym, a.interval, to_eastern(now).date(), a.offline, real_today), now
def cmd_check(a):
cfg = read_config(a.config)
opts = _opts(a, cfg)
sym = a.symbol.upper()
chart, now = _load(a, sym, parse_now(a.now) if a.now else None)
res = evaluate(chart, now, **opts)
if a.write:
write_json(a.write, entry_doc(res, now))
if a.json:
print(json.dumps(public(res), indent=2))
else:
for line in describe(res):
print(line)
if a.write:
print("Wrote %s (status %s)." % (a.write, res["status"]))
return 0 if res["status"] == "triggered" else 1
def cmd_watch(a):
cfg = read_config(a.config)
opts = _opts(a, cfg)
sym = a.symbol.upper()
if a.every <= 0:
raise EntryError("--every must be above 0 seconds")
start = parse_now(a.now) if a.now else None
if a.offline or start is not None:
if start is None:
start = _load(a, sym, None)[1]
clock = SimClock(start)
now_fn, sleep_fn = clock.now, clock.sleep
else:
now_fn, sleep_fn = utc_now, _sleep
real_today = to_eastern(utc_now()).date()
def provider(now):
return get_chart(sym, a.interval, to_eastern(now).date(), a.offline, real_today)
until = None
if a.until:
t = parse_hhmm(a.until, "--until")
until = datetime.datetime.combine(to_eastern(now_fn()).date(), t)
def on_trigger(res, now):
write_json(a.out, entry_doc(res, now))
print("Wrote %s." % a.out, flush=True)
def emit(line):
print(line, flush=True)
code, _ = watch_loop(provider, now_fn, sleep_fn, emit, opts, every=a.every, until=until,
on_trigger=on_trigger)
return code
def cmd_watchlist(a):
cfg = read_config(a.config)
opts = _opts(a, cfg)
if not os.path.exists(a.watchlist):
raise EntryError("no watchlist at %s: run /trader-scanner first (it writes the hits there)" % a.watchlist)
try:
with open(a.watchlist, encoding="utf-8") as fh:
doc = json.load(fh)
except ValueError as e:
raise EntryError("%s is not valid JSON: %s" % (a.watchlist, e))
hits = [h for h in (doc.get("hits") or []) if isinstance(h, dict) and h.get("symbol")]
if not hits:
raise EntryError("no hits in %s: the scanner found nothing to watch" % a.watchlist)
if a.offline and not os.path.isdir(a.offline):
raise EntryError("watchlist --offline wants a folder of <TICKER>.json files")
now = parse_now(a.now) if a.now else None
rows = []
for i, h in enumerate(hits):
sym = str(h["symbol"]).upper()
o = dict(opts)
if a.setup == "level" and o["level"] is None:
o["level"] = h.get("level")
try:
if a.setup == "level" and o["level"] is None:
raise EntryError("needs a level: --level PRICE or a \"level\" in the watchlist")
if i and not a.offline:
_sleep(PAUSE)
chart, when = _load(a, sym, now)
rows.append((sym, evaluate(chart, when, **o), None))
except EntryError as e:
rows.append((sym, None, str(e)))
if a.json:
print(json.dumps([{"symbol": s, "result": public(r) if r else None, "error": e} for s, r, e in rows], indent=2))
else:
print("%-6s %-9s %-8s %-8s %-9s %-9s %s" % ("SYMBOL", "STATUS", "TIME", "PRICE", "LEVEL", "LAST", "VS LEVEL"))
for s, r, e in rows:
if e:
print("%-6s error: %s" % (s, e))
continue
t = r.get("trigger") or {}
last = r.get("last") or {}
status = SHORT.get(r["phase"], r["status"]) if r["status"] != "triggered" else "triggered"
print("%-6s %-9s %-8s %-8s %-9s %-9s %s" % (
s, status[:9], t.get("time") or "-", ("$%.2f" % t["price"]) if t else "-",
("$%.2f" % r["level"]) if r.get("level") is not None else "-",
("$%.2f" % last["close"]) if last else "-",
("%+.2f%%" % last["vs_level_pct"]) if last.get("vs_level_pct") is not None else "-"))
n = sum(1 for _, r, _ in rows if r and r["status"] == "triggered")
print("%d of %d triggered. Pick one, then: entry.py check <TICKER> --write, and /trader-exit." % (n, len(rows)))
print("Free Yahoo bars, unofficial and can lag. Nothing was placed.")
return 0 if any(r and r["status"] == "triggered" for _, r, _ in rows) else 1
def main(argv=None):
ap = argparse.ArgumentParser(description="Entry Timer (trader-entry): watches a setup bar by bar.")
sub = ap.add_subparsers(dest="cmd")
def common(p):
p.add_argument("--setup", choices=["orb", "level"], default="orb")
p.add_argument("--or-minutes", type=int, default=15, help="opening range length (default 15)")
p.add_argument("--interval", choices=["5m", "1m"], default="5m")
p.add_argument("--level", type=float, help="the price to close above (--setup level)")
p.add_argument("--min-volume-x", type=float, help="trigger bar volume vs the range bars' average")
p.add_argument("--side", default="buy", choices=["buy", "long", "sell", "short"], help="v2: buy only")
p.add_argument("--now", help='pretend it is this New York time, e.g. "2026-10-19 10:15"')
p.add_argument("--offline", metavar="PATH", help="saved Yahoo chart JSON (.json/.json.gz) or a folder")
p.add_argument("--config", default="trader/config.json")
p = sub.add_parser("check", help="the setup's status right now")
p.add_argument("symbol")
common(p)
p.add_argument("--write", nargs="?", const="trader/entry.json", metavar="PATH",
help="save the result (default trader/entry.json)")
p.add_argument("--json", action="store_true")
p = sub.add_parser("watch", help="poll bar by bar until it triggers or expires")
p.add_argument("symbol")
common(p)
p.add_argument("--every", type=float, default=30, help="seconds between polls while Yahoo is behind")
p.add_argument("--until", help="stop at this New York time (HH:MM)")
p.add_argument("--out", default="trader/entry.json", help="where a trigger is written")
p = sub.add_parser("watchlist", help="check every hit in trader/watchlist.json")
common(p)
p.add_argument("--watchlist", default="trader/watchlist.json")
p.add_argument("--json", action="store_true")
a = ap.parse_args(argv)
if not a.cmd:
ap.print_help()
return 1
try:
return {"check": cmd_check, "watch": cmd_watch, "watchlist": cmd_watchlist}[a.cmd](a)
except EntryError as e:
print("entry.py: %s" % e, file=sys.stderr)
return 1
except KeyboardInterrupt:
print("entry.py: stopped.", file=sys.stderr)
return 1
if __name__ == "__main__":
sys.exit(main())