Skip to content

Ultra-Smashed/daytrader-skill / skills/dt-einstieg

dt-einstieg

Verified

Einstiegs-Timer. Beobachtet ein Setup Kerze für Kerze und sagt dir den Moment für den Einstieg. Liest kostenlose Yahoo-Kerzen (5 oder 1 Minute), bildet die Opening Range (an XETRA 9:00 bis 9:15 Uhr, in New York 9:30 bis 9:45 ET) und meldet den Einstieg bei der ersten geschlossenen Kerze, die ÜBER dem Range-Hoch schließt, oder über einem Level, das du vorgibst (etwa ein 20-Tage-Hoch aus dem Scanner), auf Wunsch mit Volumenprüfung. Sagt WARTEN und wie weit, AUSGELÖST mit Zeit und Kurs, ABGELAUFEN oder noch nicht offen, nennt ehrlich das Alter der Daten (XETRA bei Yahoo ca. 15 Minuten verzögert) und schreibt trader/entry.json für /dt-ausstieg. Nur Long. Platziert nie eine Order. Nutze den Skill, wenn jemand sagt „wann steige ich ein“, „beobachte SAP“, „ist es ausgelöst“, „sag mir, wann ich kaufen soll“, „hat SAP die Range gebrochen“, „Entry-Timing“, „prüf meine Watchlist“, oder auf Englisch „tell me when to get in“, „watch the setup“, „has it broken out“, „time my entry“; nach /dt-scanner und /dt-news, vor /dt-ausstieg.

FileKindSize
SKILL.mdskill md13.5 KB
entry.pyscript49.2 KB
markt.pyscript13.5 KB
#!/usr/bin/env python3
"""Einstiegs-Timer für dt-einstieg: beobachtet ein Setup Kerze für Kerze und sagt
den Moment für den Einstieg. Nur Standardbibliothek. Nur Long. Platziert nie eine Order.

    python3 entry.py check SAP.DE                         # Opening-Range-Breakout, 5-Minuten-Kerzen
    python3 entry.py check SAP.DE --now "2026-10-27 10:55" --offline SAP.DE.json
    python3 entry.py check TSLA --setup level --level 371,20     # erster Schluss über einem Kurs
    python3 entry.py check TSLA --interval 1m --min-volume-x 1.5 --write
    python3 entry.py watch SAP.DE --every 30 --until 17:00 # eine Zeile je geschlossener Kerze
    python3 entry.py watchlist                            # jeder Treffer in trader/watchlist.json

Der Markt folgt aus dem Symbol: SAP.DE ist XETRA (9:00 bis 17:30 Uhr), TSLA ist US
(9:30 bis 16:00 ET). Alle Zeiten gelten in der Ortszeit des Marktes; --now ohne
Offset ebenso.

Setups (nur Long):
  orb    Opening-Range-Breakout. Die Range ist Hoch und Tief der ersten
         --or-minutes (Standard 15: an XETRA die Kerzen 9:00, 9:05 und 9:10,
         in New York 9:30, 9:35 und 9:40). Ausgelöst wird bei der ersten
         GESCHLOSSENEN Kerze nach der Range, die ÜBER dem Range-Hoch schließt.
         Ein Docht über das Hoch ist kein Auslöser.
  level  die erste geschlossene Kerze, die über --level schließt (zum Beispiel
         ein 20-Tage-Hoch aus dt-scanner).
  --min-volume-x X  die auslösende Kerze braucht zusätzlich mindestens das
         X-Fache des Durchschnittsvolumens der Range-Kerzen.

Die Zeit eines Auslösers ist der SCHLUSS der Kerze (die 10:50-Kerze schließt um
10:55 Uhr), der Kurs ist ihr Schlusskurs. Nur Kerzen im Raster zählen (Yahoos
Live-Tick, z. B. 9:57:36, fällt weg), und eine Kerze zählt erst, wenn sie
geschlossen ist.

Status: triggered (AUSGELÖST); waiting (WARTEN: noch nicht offen, Range bildet
sich, oder noch kein Schluss über dem Level); expired (ABGELAUFEN: kein Auslöser
bis no_entries_after, XETRA 17:00, US 15:30; an einem verkürzten Tag rückt die
Grenze mit dem Schluss vor); no-data (Börse heute zu oder keine Kerzen).

trader/config.json (optional): "no_entries_before" / "no_entries_after" oder je
Markt "zeiten": {"xetra": {...}, "us": {...}}, in Ortszeit des Marktes.

Datenalter: Yahoo liefert XETRA-Kerzen ca. 15 Minuten verzögert. Das Tool zeigt
das Alter der letzten Kerze und des letzten Kurses und zählt eine Kerze erst,
wenn Yahoo sie geliefert hat (oder nach Verzögerung plus einer Minute).

watch wacht nach jedem Kerzenschluss auf (live an XETRA zusätzlich um die
Verzögerung später), fragt alle --every Sekunden nach, solange Yahoo die neue
Kerze nicht hat, druckt eine Zeile je geschlossener Kerze und stoppt beim
Auslöser (Exit 0, schreibt trader/entry.json), beim Ablauf, zum Schluss oder bei
--until (Exit 1). Mit --now oder --offline läuft es auf einer simulierten Uhr.

Daten: Yahoos kostenloses Chart-JSON (inoffiziell, verzögert, Kerzen statt Einzelumsätze)
  https://query2.finance.yahoo.com/v8/finance/chart/SAP.DE?range=1d&interval=5m
  bei HTTP 429 oder 5xx Wechsel zu query1; ein 429 bekommt nach einer Pause einen zweiten Versuch.
  --offline PFAD liest ein gespeichertes Chart-JSON (.json oder .json.gz) oder
  PFAD/<SYMBOL>.json in einem Ordner. Ohne --now gilt die Zeit der Datei
  (meta.regularMarketTime).

Exit-Codes: check 0 = ausgelöst, 1 = alles andere oder ein Fehler. watch 0 bei
Auslöser, sonst 1. watchlist 0, wenn mindestens ein Symbol ausgelöst hat.
"""

import argparse
import datetime
import gzip
import json
import os
import re
import sys
import time
import urllib.error
import urllib.request

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import markt  # noqa: E402

UA = "Mozilla/5.0 (compatible; daytrader-skill/1.0; +https://thanisch.co)"
PAUSE = 0.5      # Sekunden zwischen Anfragen an den kostenlosen Endpunkt
BACKOFF = 5.0    # Sekunden vor dem zweiten Versuch nach HTTP 429
GRACE = 2        # Sekunden nach Kerzenschluss, bevor watch nachfragt
SETTLE = 60      # so lange darf eine geschlossene Kerze auf Yahoos Daten warten
HOSTS = ("query2", "query1")
INTERVALS = {"5m": 300, "1m": 60}
DELAY_MIN = {"xetra": 15, "us": 0}   # Yahoos Verzögerung je Markt in Minuten
EPOCH = datetime.datetime(1970, 1, 1)
CALENDAR_YEARS = markt.CALENDAR_YEARS


class EntryError(Exception):
    pass


# ---------------------------------------------------------------- Zeit

def utc_now():
    return markt.utc_now()


def utc_of(ts):
    """Unix-Sekunden -> naive UTC, ohne die Zeitzone des Rechners."""
    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 to_local(utc):
    return markt.to_local(utc)


def to_eastern(utc):
    return markt.to_eastern(utc)


def local_to_utc(local):
    return markt.local_to_utc(local)


def parse_now(text):
    """--now -> naive UTC. "2026-10-27 10:55" (oder ...T10:55, oder nur 10:55 für heute)
    gilt in Ortszeit des Marktes; ein Offset oder Z macht die Zeit absolut."""
    if not text:
        return utc_now()
    t = str(text).strip()
    for suffix in (" ET", " UHR"):
        if t.upper().endswith(suffix):
            t = t[:-len(suffix)].strip()
    if re.match(r"^\d{1,2}:\d{2}(:\d{2})?$", t):
        h, rest = t.split(":", 1)
        t = "%s %02d:%s" % (to_local(utc_now()).date().isoformat(), int(h), rest)
    return markt.parse_now(t, error=EntryError)


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 erwartet eine Uhrzeit in %s wie 15:30, nicht %r" % (what, markt.info()["zone"], text))
    return datetime.time(int(m.group(1)), int(m.group(2)))


def hm(t):
    """10:10, 09:00: die Form für Dateien und JSON."""
    return markt.clock(t)


def _nolead(s):
    return s[1:] if s.startswith("0") and len(s) > 1 and s[1].isdigit() else s


def short(t):
    """9:55, 10:10: Kerzennamen in Sätzen."""
    return _nolead(markt.clock(t))


def zeit(t):
    """9:55 Uhr, 10:15 ET."""
    return _nolead(markt.clock_label(t))


def zeit2(local):
    """XETRA: 10:55 Uhr. US: 10:15 ET (16:15 Uhr)."""
    return _nolead(markt.clock_both(local))


def ampm(t):
    h = t.hour % 12 or 12
    return "%d:%02d %s" % (h, t.minute, "AM" if t.hour < 12 else "PM")


def geld(x):
    return markt.money(x)


def minuten(n):
    return "1 Minute" if n == 1 else "%d Minuten" % n


def trading_day(d):
    """(Handelstag?, Grund) für den aktuellen Markt."""
    return markt.trading_day(d)


def session(d):
    """(Eröffnung, Schluss) in Ortszeit, oder None an einem handelsfreien Tag."""
    return markt.session(d)


def next_open(d):
    nd = d + datetime.timedelta(days=1)
    for _ in range(15):
        s = session(nd)
        if s:
            return "%s %s" % (nd.isoformat(), hm(s[0]))
        nd += datetime.timedelta(days=1)
    return None


# ---------------------------------------------------------------- Yahoo

def yahoo_symbol(sym):
    return markt.to_yahoo(sym)


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):
    """Die kleinste Yahoo-Range, die die Sitzung von `day` noch enthält."""
    back = (today - day).days
    if back <= 0:
        return "1d"
    if back <= 6:
        return "5d"
    if interval == "1m":
        raise EntryError("Yahoo hält 1-Minuten-Kerzen nur etwa eine Woche: nimm --interval 5m für %s"
                         % markt.date_de(day))
    if back <= 28:
        return "1mo"
    if back <= 58:
        return "60d"
    raise EntryError("Yahoo hält 5-Minuten-Kerzen nur etwa 60 Tage: %s liegt zu weit zurück" % markt.date_de(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 auf Yahoo: erst query2, bei 429 oder 5xx query1.
    Ein HTTP 429 bekommt nach BACKOFF Sekunden einen zweiten Versuch am selben Host."""
    last = "keine Antwort"
    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 nennt den Grund im Body: ein unbekanntes Symbol
                        body = e.read().decode("utf-8", "replace")
                except Exception:
                    body = None
                finally:
                    e.close()
                if code == 404:
                    if body:
                        return body
                    raise EntryError("Yahoo hat keinen Chart unter %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 antwortet mit HTTP %d auf %s" % (code, url.split("?")[0]))
            except urllib.error.URLError as e:
                last = "keine Verbindung: %s" % (e.reason,)
                break
            except OSError as e:
                last = "Netzwerkfehler: %s" % (e,)
                break
    raise EntryError("Yahoo antwortet nicht (%s auf query2 und query1): warte eine Minute und versuch es noch einmal"
                     % last)


def parse_chart(text, sym):
    """Yahoo-Chart-JSON v8 -> {symbol, meta, bars, prev_close, data_time}.
    Kerzen ohne Schlusskurs fallen hier weg, Ticks außerhalb des Rasters später."""
    try:
        data = json.loads(text)
        res = data["chart"]["result"]
    except (ValueError, KeyError, TypeError):
        raise EntryError("Yahoo hat für %s etwas Unerwartetes geschickt" % sym)
    if not res:
        err = (data.get("chart") or {}).get("error") or {}
        raise EntryError("Yahoo hat keine Daten für %s: %s" % (sym, err.get("description") or "unbekanntes Symbol"))
    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("keine Offline-Datei für %s in %s (erwartet %s.json)" % (sym, path, sym))
    if not os.path.exists(path):
        raise EntryError("keine Offline-Datei %s" % path)
    return path


def get_chart(sym, interval, day=None, offline=None, today=None):
    """Kerzen eines Symbols, von Yahoo (range=1d für heute) oder aus einer gespeicherten Datei."""
    sym = sym.upper()
    if offline:
        f = offline_file(offline, sym)
        try:
            text = read_text(f)
        except (OSError, ValueError) as e:
            raise EntryError("%s ist nicht lesbar: %s" % (f, e))
    else:
        today = today or to_local(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("die Datei enthält %s, nicht %s" % (ch["symbol"], sym))
    gran = ch["meta"].get("dataGranularity")
    if gran and gran != interval:
        raise EntryError("%s hat %s-Kerzen, nicht %s: nimm --interval %s" % (sym, gran, interval, gran))
    return ch


# ---------------------------------------------------------------- die Regel

def read_config(path):
    """trader/config.json als dict (leer, wenn es sie nicht gibt). Die Zeitfenster
    werden für beide Märkte geprüft, gelesen werden sie über markt.windows()."""
    doc = {}
    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 ist kein gültiges JSON: %s" % (path, e))
        if not isinstance(doc, dict):
            raise EntryError("%s muss ein JSON-Objekt sein" % path)
        doc = {k: v for k, v in doc.items() if v not in ("", None)}
    for m in markt.MARKETS:
        with markt.using(m):
            w = markt.windows(doc)
            for k in ("no_entries_before", "no_entries_after"):
                parse_hhmm(w[k], k)
    return doc


def r2(x):
    return None if x is None else round(float(x), 2) + 0.0   # + 0.0 macht aus -0.0 eine 0.0


def early_cutoff(day, t, close_dt):
    """An einem verkürzten Tag rückt die Grenze mit dem Schluss vor: 17:00 (30 Minuten vor
    17:30) wird an XETRA zu 13:30 vor einem Schluss um 14:00, in New York 15:30 zu 12:30.
    Eine Grenze, die schon vor dem verkürzten Schluss liegt, bleibt."""
    mk = markt.info()
    at = datetime.datetime.combine(day, t)
    if at < close_dt:
        return at
    moved = at - (datetime.datetime.combine(day, mk["close"]) - close_dt)
    return moved if moved.time() > mk["open"] else close_dt


def evaluate(chart, now_utc, setup="orb", or_minutes=15, interval="5m", level=None,
             min_volume_x=None, cfg=None, market=None):
    """Reine Funktion: der Status des Setups zu now_utc aus den Kerzen einer Sitzung.
    Der Markt folgt aus dem Symbol des Charts, außer `market` ist gesetzt."""
    with markt.using(market or markt.market_of(chart["symbol"])):
        return _evaluate(chart, now_utc, setup, or_minutes, interval, level, min_volume_x, cfg)


def _evaluate(chart, now_utc, setup, or_minutes, interval, level, min_volume_x, cfg):
    cfg = cfg if isinstance(cfg, dict) else {}
    if interval not in INTERVALS:
        raise EntryError("--interval ist 5m oder 1m")
    step = INTERVALS[interval]
    if or_minutes <= 0 or (or_minutes * 60) % step:
        raise EntryError("--or-minutes muss ein Vielfaches der %s-Kerzen sein" % interval)
    if setup not in ("orb", "level"):
        raise EntryError("--setup ist orb oder level")
    if setup == "level" and level is None:
        raise EntryError("--setup level braucht --level KURS (zum Beispiel ein 20-Tage-Hoch)")
    mk = markt.info()
    delay = DELAY_MIN[mk["key"]] * 60
    win = markt.windows(cfg)
    n_or = or_minutes * 60 // step
    local = to_local(now_utc)
    day = local.date()
    now_ts = ts_of(now_utc)
    res = {"symbol": chart["symbol"], "market": mk["key"], "currency": mk["currency"], "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": markt.in_calendar(day), "delay_minutes": DELAY_MIN[mk["key"]],
           "data_age": None, "_bars": []}
    dt = chart.get("data_time")
    res["data_time"] = markt.ts_to_local(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="%s handelt heute nicht (%s)" % (mk["exchange"], 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 = markt.early_close(day)
    before = datetime.datetime.combine(day, parse_hhmm(win["no_entries_before"], "no_entries_before"))
    cutoff = early_cutoff(day, parse_hhmm(win["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=early, no_entries_before=hm(before),
               no_entries_after=hm(cutoff))

    by_slot = {}
    for b in chart["bars"]:
        if b["t"] % step:
            continue                       # Yahoos Live-Tick (9:57:36) ist keine Kerze
        lt = markt.ts_to_local(b["t"])
        if lt.date() != day or not (open_dt <= lt < close_dt):
            continue
        slot = int((lt - open_dt).total_seconds()) // step
        by_slot[slot] = dict(b, lt=lt, end=lt + datetime.timedelta(seconds=step), slot=slot)
    bars, pending, newest = [], None, None
    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 b["lt"] <= local:
            newest = b
        if end_ts <= now_ts:
            # Nach der Uhr geschlossen. Live zählt sie, sobald Yahoo nachgezogen hat: der letzte Kurs
            # liegt am oder nach dem Schluss, es gibt eine spätere Kerze, oder Verzögerung plus eine Minute ist um.
            if dt is None or dt >= end_ts or slot < top or now_ts >= end_ts + delay + SETTLE:
                bars.append(b)
            else:
                pending = b
                res["forming"] = {"bar_start": hm(b["lt"]), "closes": ampm(b["end"]), "price": r2(b["c"])}
                res["lag_note"] = ("Yahoos letzter Kurs ist von %s, vor dem Schluss der %s-Kerze: sie zählt, "
                                   "sobald Yahoo nachzieht (%s)" % (
                                       _nolead(markt.ts_to_local(dt).strftime("%H:%M:%S")) + " " + mk["suffix"],
                                       short(b["lt"]),
                                       "an XETRA kommen die Kerzen ca. %d Minuten verzögert" % (delay // 60)
                                       if delay else "höchstens eine Minute"))
        elif b["lt"] <= local:
            res["forming"] = {"bar_start": hm(b["lt"]), "closes": ampm(b["end"]), "price": r2(b["c"])}
    res["_bars"] = bars
    res["bars_closed"] = len(bars)
    if newest:
        replay = dt is not None and dt > now_ts
        res["data_age"] = {
            "last_bar": hm(newest["lt"]), "minutes": int((local - newest["lt"]).total_seconds() // 60),
            "last_trade": markt.ts_to_local(dt).strftime("%H:%M:%S") if dt and not replay else None,
            "last_trade_minutes": int((now_ts - dt) // 60) if dt and not replay else None,
            "replay": replay, "delay_minutes": delay // 60}

    if local < open_dt:
        res.update(phase="pre-open", reason="%s öffnet um %s%s" % (mk["exchange"], zeit(o), (
            " und die %d-Minuten-Range steht um %s" % (or_minutes, zeit(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
    range_done = local >= or_end and (len(or_bars) >= n_or or (bars and bars[-1]["slot"] >= n_or - 1)
                                      or now_ts >= ts_of(local_to_utc(or_end)) + delay + SETTLE)
    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": bool(range_done), "avg_volume": int(round(avg_vol))}
    if setup == "orb":
        if not range_done:
            if local < or_end:
                why = "%d von %d Range-Kerzen geschlossen; die Range steht um %s" % (len(or_bars), n_or, zeit(or_end))
            else:
                why = ("%d von %d Range-Kerzen da; Yahoo liefert die letzte noch nach (ca. %d Minuten verzögert)"
                       % (len(or_bars), n_or, delay // 60) if delay else
                       "%d von %d Range-Kerzen da; Yahoo liefert die letzte noch nach" % (len(or_bars), n_or))
            res.update(phase="forming", reason=why)
            return res
        if not or_bars:
            res.update(status="no-data", phase="open", reason="Yahoo hat keine Kerzen für die Opening Range geschickt")
            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["lt"]), "close": r2(last["c"]),
                       "vs_level_pct": r2(100.0 * (last["c"] / lvl - 1))}
    hoch = "dem Range-Hoch" if setup == "orb" else "dem Level"

    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="die %s-Kerze hat über %s geschlossen" % (short(trig["lt"]), hoch))
        res["trigger"] = {"time": ampm(trig["end"]), "close_time": hm(trig["end"]), "bar_start": hm(trig["lt"]),
                          "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) < local_to_utc(trig["end"]):
            res["data_note"] = ("Yahoos letzter Kurs ist von %s, vor dem Schluss dieser Kerze: ihr Schlusskurs "
                                "kann sich noch um ein, zwei Cent bewegen"
                                % (_nolead(markt.ts_to_local(dt).strftime("%H:%M:%S")) + " " + mk["suffix"]))
        return res
    if not bars:
        res.update(status="no-data", phase="open",
                   reason="Yahoo hat für den %s noch keine Kerzen geschickt" % markt.date_de(day))
        return res
    what = "Schluss über %s %s" % (hoch, geld(lvl))
    grid_end = open_dt + datetime.timedelta(seconds=int((cutoff - open_dt).total_seconds()) // step * step)
    behind = bool(delay) and bars[-1]["end"] < grid_end and now_ts < ts_of(local_to_utc(cutoff)) + delay + SETTLE
    if local >= cutoff and not (pending and pending["end"] <= cutoff) and not behind:
        res.update(status="expired", phase="after-close" if local >= close_dt else "after-cutoff",
                   reason="kein %s bis %s, dem letzten Zeitpunkt für einen neuen Einstieg%s" % (
                       what, zeit(cutoff), " (heute verkürzter Handel bis %s)" % zeit(c) if early else ""))
        return res
    res["phase"] = "open"
    if local >= cutoff:
        res["phase"] = "after-cutoff"
        res["reason"] = ("nach %s keine neuen Einstiege, aber Yahoo liefert die Kerzen bis %s noch nach "
                         "(ca. %d Minuten verzögert); letzter Schluss %s (%s-Kerze)" % (
                             zeit(cutoff), zeit(cutoff), delay // 60, geld(last["c"]), short(last["lt"])))
    elif last["c"] > lvl and last in thin:
        res["reason"] = ("die %s-Kerze hat bei %s darüber geschlossen, aber nur mit dem %s-Fachen des "
                         "Range-Volumens, unter deinem Minimum von %s" % (
                             short(last["lt"]), geld(last["c"]), markt.num(last["v"] / avg_vol if avg_vol else 0),
                             markt.num(min_volume_x)))
    elif last["c"] > lvl and last["end"] < before:
        res["reason"] = "die %s-Kerze hat bei %s darüber geschlossen, aber vor %s gibt es keine Einstiege (Config)" % (
            short(last["lt"]), geld(last["c"]), zeit(before))
    else:
        gap = lvl - last["c"]
        res["reason"] = "letzter Schluss %s (%s-Kerze), %s %s %s %s (%s)" % (
            geld(last["c"]), short(last["lt"]), geld(abs(gap)), "unter" if gap >= 0 else "über",
            hoch, geld(lvl), markt.pct(100.0 * (last["c"] / lvl - 1), sign=True))
    return res


def public(res):
    """Das Ergebnis ohne die interne Kerzenliste, fertig für JSON."""
    return {k: v for k, v in res.items() if not k.startswith("_")}


def entry_doc(res, now_utc):
    """trader/entry.json, die Vertragsform (plus Begründung in Worten)."""
    t = res.get("trigger") or {}
    orr = res.get("opening_range")
    return {"created_by": "dt-einstieg", "symbol": res["symbol"], "market": res.get("market"),
            "currency": res.get("currency"), "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", "delay_minutes": res.get("delay_minutes"), "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, ensure_ascii=False)
        fh.write("\n")


# ---------------------------------------------------------------- Worte

LABEL = {"triggered": "AUSGELÖST", "waiting": "WARTEN", "expired": "ABGELAUFEN", "no-data": "KEINE DATEN"}
PHASE_LABEL = {"pre-open": "WARTEN (noch nicht offen)", "forming": "WARTEN (Range bildet sich)",
               "closed": "KEINE DATEN (Börse zu)"}
SHORT = {"pre-open": "WARTEN", "forming": "WARTEN", "closed": "ZU"}
SOURCE = {"xetra": "deutsche-boerse.com", "us": "nyse.com"}


def setup_name(res):
    if res["setup"] == "orb":
        return "Opening-Range-Breakout (%d-Minuten-Range)" % res["or_minutes"]
    return "Schluss über %s" % geld(res["level"]) if res["level"] is not None else "Schluss über einem Level"


def _dt(text):
    return datetime.datetime.strptime(text, "%Y-%m-%d %H:%M:%S")


def data_line(res):
    """Wie alt die Daten sind, ehrlich: Yahoo ist kostenlos und an XETRA verzögert."""
    da = res.get("data_age")
    if not da:
        return None
    delay = da.get("delay_minutes") or 0
    if da["replay"]:
        s = "Rückblick auf gespeicherte Kerzen (Datei bis %s %s)." % (
            markt.day_label(_dt(res["data_time"]).date()), zeit(_dt(res["data_time"])))
        if delay:
            s += " Live kämen diese Kerzen bei Yahoo ca. %d Minuten verzögert." % delay
        return s
    last = datetime.datetime.strptime(da["last_bar"], "%H:%M")
    s = "Datenstand: letzte Kerze %s, %s alt" % (zeit(last), minuten(da["minutes"]))
    if da.get("last_trade"):
        lt = datetime.datetime.strptime(da["last_trade"], "%H:%M:%S")
        s += "; letzter Kurs von %s (%s alt)" % (zeit(lt), minuten(da["last_trade_minutes"]))
    if delay:
        s += ". Yahoo liefert XETRA-Kerzen ca. %d Minuten verzögert: das ist kein Echtzeitkurs." % delay
    else:
        s += " (Yahoo, kostenlos, kann verzögert sein)."
    return s


def describe(res):
    """Zeilen für Menschen."""
    with markt.using(res.get("market") or markt.current()):
        return _describe(res)


def _describe(res):
    when = _dt(res["now"])
    step = INTERVALS[res["interval"]] // 60
    delay = res.get("delay_minutes") or 0
    bars = "5-Minuten-Kerzen" if res["interval"] == "5m" else "1-Minuten-Kerzen"
    out = ["%s  %s %s  %s auf %s (Yahoo, kostenlos, inoffiziell)" % (
        res["symbol"], markt.day_label(when.date()), zeit2(when), setup_name(res), bars)]
    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 bis %s: Hoch %s, Tief %s (%d von %d Kerzen%s)." % (
            short(start), zeit(end), geld(orr["high"]), geld(orr["low"]), orr["bars"], orr["of"],
            "" if orr["complete"] else ", bildet sich noch"))
    label = PHASE_LABEL.get(res["phase"]) or LABEL.get(res["status"], res["status"].upper())
    t = res.get("trigger")
    if t:
        tend = datetime.datetime.combine(when.date(), datetime.datetime.strptime(t["close_time"], "%H:%M").time())
        out.append("AUSGELÖST %s zu %s: die %s-Kerze (Kerze %d) hat über %s %s geschlossen (%s%s)." % (
            zeit2(tend), geld(t["price"]), short(datetime.datetime.strptime(t["bar_start"], "%H:%M")), t["bar_index"],
            "dem Range-Hoch" if res["setup"] == "orb" else "dem Level", geld(res["level"]),
            markt.pct(t["pct_over"], sign=True),
            (", %s-faches Range-Volumen" % markt.num(t["volume_x"])) if res.get("min_volume_x") and t.get("volume_x")
            else ""))
        line = data_line(res)
        if line:
            out.append(line)
        since = res.get("minutes_since", 0)
        if since <= step:
            out.append("Jetzt ist der Moment für den Einstieg, wenn du den Trade nimmst. Es wurde nichts platziert.")
            if delay:
                out.append("Live siehst du diese Kerze bei Yahoo erst ca. %d Minuten später: prüf den aktuellen Kurs "
                           "in deiner Broker-App, bevor du handelst." % delay)
        elif delay and since <= step + delay:
            out.append("Die Kerze ist %s alt, weil Yahoo XETRA-Kurse ca. %d Minuten verzögert liefert. Der Kurs hat "
                       "sich seitdem bewegt: prüf ihn in deiner Broker-App, bevor du einsteigst. "
                       "Es wurde nichts platziert." % (minuten(since), delay))
        else:
            if res.get("last"):
                out.append("Das war vor %s; der letzte Schluss ist %s (%s-Kerze). Ein später Einstieg ist ein "
                           "anderer Trade: Kurs, Stop-Abstand und Chancen haben sich verschoben." % (
                               minuten(since), geld(res["last"]["close"]),
                               short(datetime.datetime.strptime(res["last"]["bar_start"], "%H:%M"))))
            out.append("Es wurde nichts platziert.")
        if res.get("data_note"):
            out.append(res["data_note"] + ".")
        out.append("Weiter: Stop und Ziel festlegen, BEVOR du kaufst: /dt-ausstieg "
                   "(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"):
            fstart = datetime.datetime.strptime(f["bar_start"], "%H:%M")
            out.append("Die %s-Kerze läuft noch (bisher %s, schließt %s); sie zählt erst, wenn sie geschlossen ist." % (
                short(fstart), geld(f["price"]), zeit(fstart + datetime.timedelta(minutes=step))))
        line = data_line(res)
        if line and res["status"] != "no-data":
            out.append(line)
        if res["status"] == "expired":
            out.append("Heute kein Einstieg mehr mit diesem Setup. Es wurde nichts platziert.")
        if res.get("next_open"):
            nxt = datetime.datetime.strptime(res["next_open"], "%Y-%m-%d %H:%M")
            out.append("Nächste Eröffnung: %s %s." % (markt.day_label(nxt.date()), zeit2(nxt)))
    if res.get("early_close"):
        out.append("Heute verkürzter Handel bis %s (%s): keine neuen Einstiege nach %s." % (
            zeit(datetime.datetime.strptime(res["closes"], "%H:%M")), res["early_close"],
            zeit(datetime.datetime.strptime(res["no_entries_after"], "%H:%M"))))
    if not res.get("calendar_known"):
        out.append("Der Feiertagskalender deckt nur %s ab: prüf dieses Datum bei %s." % (
            " und ".join(map(str, CALENDAR_YEARS)), SOURCE.get(res.get("market"), "der Börse")))
    return out


def bar_line(b, res):
    """Eine watch-Zeile für eine gerade geschlossene Kerze."""
    with markt.using(res.get("market") or markt.current()):
        return _bar_line(b, res)


def _bar_line(b, res):
    start = short(b["lt"])
    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 bisher %s bis %s" % (geld(min(x["l"] for x in seen)), geld(max(x["h"] for x in seen)))
        if b["slot"] == n_or - 1:
            note = "Opening Range steht: Hoch %s, Tief %s" % (geld(orr["high"]), geld(orr["low"]))
    elif t and t["bar_index"] == b["slot"]:
        note = "AUSGELÖST: Schluss über %s (%s). Jetzt einsteigen, wenn du ihn nimmst: %s, %s" % (
            geld(lvl), markt.pct(t["pct_over"], sign=True), zeit2(b["end"]), geld(t["price"]))
    elif lvl is None:
        note = ""
    elif b["c"] > lvl:
        note = "über %s" % geld(lvl)
        if res["setup"] == "level" or b["slot"] >= n_or:
            avg = orr.get("avg_volume")
            if res.get("min_volume_x") and avg:
                note += ", aber Volumen %sx unter %sx" % (markt.num(b["v"] / float(avg)), markt.num(res["min_volume_x"]))
            elif b["end"] < datetime.datetime.combine(b["lt"].date(), parse_hhmm(res["no_entries_before"], "x")):
                note += ", aber keine Einstiege vor %s" % zeit(parse_hhmm(res["no_entries_before"], "x"))
    else:
        note = "%s unter %s" % (geld(lvl - b["c"]), geld(lvl))
    return "%5s-Kerze  Schluss %s  %s" % (start, geld(b["c"]), note)


# ---------------------------------------------------------------- watch

class SimClock(object):
    """Eine Uhr, die nur beim Schlafen weiterläuft: spielt einen Tag ohne Warten ab."""

    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, lag=0):
    """Fragt Kerze für Kerze ab bis zum Auslöser (0), Ablauf, Schluss oder --until (1).
    provider(now_utc) -> chart, clock() -> naive UTC, sleep(sekunden), emit(zeile).
    lag: Sekunden, die Yahoo hinterherhängt (live an XETRA 900); watch wacht entsprechend später auf.
    Es schläft in Schritten von höchstens `every` Sekunden und liest die Uhr jedes Mal neu,
    damit ein Rechner, der eingeschlafen war, beim Aufwachen sofort aufholt."""
    with markt.using(opts.get("market") or markt.current()):
        return _watch_loop(provider, clock, sleep, emit, opts, every, until, max_errors, on_trigger, lag)


def _watch_loop(provider, clock, sleep, emit, opts, every, until, max_errors, on_trigger, lag):
    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_local(now)
        day = local.date()
        s = session(day)
        if not s:
            emit("%s: Börse heute geschlossen (%s). Nichts zu beobachten." % (
                markt.day_label(day), 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 + lag):
            if not said_preopen:
                first_close = open_dt + datetime.timedelta(seconds=step)
                emit("%s  %s: beobachte ab dem Schluss der ersten Kerze um %s%s." % (
                    zeit2(local), "noch nicht offen" if local < open_dt else "offen, noch keine Kerze geschlossen",
                    zeit(first_close), (" (bei Yahoo ca. %s, %d Minuten verzögert)" % (
                        zeit(first_close + datetime.timedelta(seconds=lag)), lag // 60)) if lag else ""))
                said_preopen = True
            next_fetch = local_to_utc(open_dt) + datetime.timedelta(seconds=step + lag + GRACE)
            continue
        try:
            chart = provider(now)
            errors = 0
        except EntryError as e:
            errors += 1
            emit("%s  Kerzen nicht lesbar: %s" % (_nolead(local.strftime("%H:%M:%S")) + " " + markt.info()["suffix"], e))
            if errors >= max_errors:
                emit("Abbruch nach %d Fehlversuchen in Folge." % 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("AUSGELÖST") 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("ABGELAUFEN  %s." % (res["reason"] or "Börsenschluss ohne Auslöser"))
            return 1, res
        if until and local >= until:
            emit("Bei --until %s ohne Auslöser gestoppt. %s." % (zeit(until), res["reason"]))
            return 1, res
        # schlafen bis kurz nach dem nächsten Kerzenschluss (plus Yahoos Verzögerung); alle `every` Sekunden, wenn Yahoo hinterherhängt
        seen = local - datetime.timedelta(seconds=lag)
        cur_slot = int((seen - open_dt).total_seconds()) // step
        behind = (not bars) or bars[-1]["slot"] < cur_slot - 1
        if behind:
            wait = every
        else:
            nxt = open_dt + datetime.timedelta(seconds=(cur_slot + 1) * step + lag + GRACE)
            wait = (nxt - local).total_seconds()
        cutoff = datetime.datetime.combine(day, parse_hhmm(res.get("no_entries_after") or "17:00", "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))


# ---------------------------------------------------------------- Befehle

def _kurs(text):
    v = markt.parse_number(text)
    if v is None:
        raise argparse.ArgumentTypeError("erwartet einen Kurs wie 214,75 oder 214.75, nicht %r" % text)
    return v


def _opts(a, cfg, market):
    if a.side in ("sell", "short"):
        raise EntryError("nur Long: keine Short-Einstiege. Beobachte stattdessen einen Kauf (--side buy).")
    if a.setup == "orb" and a.level is not None:
        raise EntryError("--level gehört zu --setup level (beim orb ist das Level das Range-Hoch)")
    if a.min_volume_x is not None and a.min_volume_x <= 0:
        raise EntryError("--min-volume-x muss über 0 liegen")
    if a.level is not None and a.level <= 0:
        raise EntryError("--level muss ein Kurs über 0 sein")
    return {"setup": a.setup, "or_minutes": a.or_minutes, "interval": a.interval, "level": a.level,
            "min_volume_x": a.min_volume_x, "cfg": cfg, "market": market}


def _market(a, sym, cfg):
    try:
        return markt.use(markt.resolve(flag=a.market, symbols=[sym], cfg=cfg))
    except markt.MarketError as e:
        raise EntryError(str(e))


def _load(a, sym, now):
    """(chart, now). Eine Offline-Datei ohne --now gilt zu ihrer eigenen Zeit."""
    real_today = to_local(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_local(now).date(), a.offline, real_today), now


DISCLAIMER = "Ein Auslöser ist ein Chart-Signal, keine Empfehlung. Keine Anlageberatung."


def cmd_check(a):
    cfg = read_config(a.config)
    sym = a.symbol.upper()
    m = _market(a, sym, cfg)
    opts = _opts(a, cfg, m)
    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, ensure_ascii=False))
    else:
        for line in describe(res):
            print(line)
        if a.write:
            print("%s geschrieben (Status %s)." % (a.write, LABEL.get(res["status"], res["status"])))
        print(DISCLAIMER)
    return 0 if res["status"] == "triggered" else 1


def cmd_watch(a):
    cfg = read_config(a.config)
    sym = a.symbol.upper()
    m = _market(a, sym, cfg)
    opts = _opts(a, cfg, m)
    if a.every <= 0:
        raise EntryError("--every muss über 0 Sekunden liegen")
    start = parse_now(a.now) if a.now else None
    simulated = bool(a.offline or start is not None)
    if simulated:
        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_local(utc_now()).date()

    def provider(now):
        return get_chart(sym, a.interval, to_local(now).date(), a.offline, real_today)

    until = None
    if a.until:
        t = parse_hhmm(a.until, "--until")
        until = datetime.datetime.combine(to_local(now_fn()).date(), t)

    def on_trigger(res, now):
        write_json(a.out, entry_doc(res, now))
        print("%s geschrieben." % 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, lag=0 if simulated else DELAY_MIN[m] * 60)
    return code


def cmd_watchlist(a):
    cfg = read_config(a.config)
    if not os.path.exists(a.watchlist):
        raise EntryError("keine Watchlist unter %s: lass zuerst /dt-scanner laufen (er schreibt die Treffer dorthin)"
                         % a.watchlist)
    try:
        with open(a.watchlist, encoding="utf-8") as fh:
            doc = json.load(fh)
    except ValueError as e:
        raise EntryError("%s ist kein gültiges 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("keine Treffer in %s: der Scanner hat nichts zum Beobachten gefunden" % a.watchlist)
    if a.offline and not os.path.isdir(a.offline):
        raise EntryError("watchlist --offline erwartet einen Ordner mit <SYMBOL>.json-Dateien")
    rows = []
    for i, h in enumerate(hits):
        sym = str(h["symbol"]).upper()
        try:
            m = _market(a, sym, cfg)
            o = _opts(a, cfg, m)
            if a.setup == "level" and o["level"] is None:
                o["level"] = markt.parse_number(h.get("level")) if h.get("level") is not None else None
            if a.setup == "level" and o["level"] is None:
                raise EntryError("braucht ein Level: --level KURS oder ein \"level\" in der Watchlist")
            if i and not a.offline:
                _sleep(PAUSE)
            chart, when = _load(a, sym, parse_now(a.now) if a.now else None)
            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, ensure_ascii=False))
        return 0 if any(r and r["status"] == "triggered" for _, r, _ in rows) else 1
    fmt = "%-8s  %-10s  %-9s  %-11s  %-11s  %-11s  %s"
    print(fmt % ("SYMBOL", "STATUS", "ZEIT", "KURS", "LEVEL", "LETZTER", "ABSTAND"))
    for s, r, e in rows:
        if e:
            print("%-8s  Fehler: %s" % (s, e))
            continue
        with markt.using(r["market"]):
            t = r.get("trigger") or {}
            last = r.get("last") or {}
            if r["status"] in ("triggered", "expired"):
                status = LABEL[r["status"]]
            else:
                status = SHORT.get(r["phase"]) or LABEL.get(r["status"], r["status"].upper())
            tz = zeit(datetime.datetime.strptime(t["close_time"], "%H:%M")) if t else "-"
            print(fmt % (s, status, tz, geld(t["price"]) if t else "-",
                         geld(r["level"]) if r.get("level") is not None else "-",
                         geld(last["close"]) if last else "-",
                         markt.pct(last["vs_level_pct"], sign=True) 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 von %d ausgelöst. Such dir einen aus, dann: entry.py check <SYMBOL> --write und /dt-ausstieg." % (
        n, len(rows)))
    print("Kostenlose Yahoo-Kerzen, inoffiziell und verzögert (XETRA ca. %d Minuten). Es wurde nichts platziert."
          % DELAY_MIN["xetra"])
    print(DISCLAIMER)
    return 0 if n else 1


def main(argv=None):
    ap = argparse.ArgumentParser(description="Einstiegs-Timer (dt-einstieg): beobachtet ein Setup Kerze für Kerze. "
                                             "Platziert nie eine Order.")
    sub = ap.add_subparsers(dest="cmd", metavar="BEFEHL")

    def common(p):
        p.add_argument("--setup", choices=["orb", "level"], default="orb",
                       help="orb = Opening-Range-Breakout (Standard), level = Schluss über --level")
        p.add_argument("--or-minutes", type=int, default=15, help="Länge der Opening Range in Minuten (Standard 15)")
        p.add_argument("--interval", choices=["5m", "1m"], default="5m", help="Kerzenlänge (Standard 5m)")
        p.add_argument("--level", type=_kurs, help="der Kurs, über dem geschlossen werden muss (--setup level)")
        p.add_argument("--min-volume-x", type=float,
                       help="Volumen der auslösenden Kerze mindestens das X-Fache des Range-Durchschnitts")
        p.add_argument("--side", default="buy", choices=["buy", "long", "sell", "short"], help="nur buy (Long)")
        p.add_argument("--market", help="xetra oder us (sonst aus dem Symbol: SAP.DE = XETRA, TSLA = US)")
        p.add_argument("--now", help='tu so, als wäre es diese Ortszeit des Marktes, z. B. "2026-10-27 10:55"')
        p.add_argument("--offline", metavar="PFAD", help="gespeichertes Yahoo-Chart-JSON (.json/.json.gz) oder ein Ordner")
        p.add_argument("--config", default="trader/config.json", help="Config (Standard trader/config.json)")

    p = sub.add_parser("check", help="der Status des Setups jetzt")
    p.add_argument("symbol", help="Symbol, z. B. SAP.DE oder TSLA")
    common(p)
    p.add_argument("--write", nargs="?", const="trader/entry.json", metavar="PFAD",
                   help="Ergebnis speichern (Standard trader/entry.json)")
    p.add_argument("--json", action="store_true", help="Ergebnis als JSON")
    p = sub.add_parser("watch", help="Kerze für Kerze abfragen, bis es auslöst oder abläuft")
    p.add_argument("symbol", help="Symbol, z. B. SAP.DE oder TSLA")
    common(p)
    p.add_argument("--every", type=float, default=30, help="Sekunden zwischen Abfragen, solange Yahoo hinterherhängt")
    p.add_argument("--until", help="um diese Ortszeit des Marktes aufhören (HH:MM)")
    p.add_argument("--out", default="trader/entry.json", help="wohin ein Auslöser geschrieben wird")
    p = sub.add_parser("watchlist", help="jeden Treffer in trader/watchlist.json prüfen")
    common(p)
    p.add_argument("--watchlist", default="trader/watchlist.json", help="Watchlist (Standard trader/watchlist.json)")
    p.add_argument("--json", action="store_true", help="Ergebnis als JSON")
    a = ap.parse_args(argv)
    if not a.cmd:
        ap.print_help()
        return 1
    with markt.restore():
        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: gestoppt.", file=sys.stderr)
            return 1


if __name__ == "__main__":
    sys.exit(main())
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall