Skip to content

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

dt-scanner

Verified

Chart-Scanner für XETRA (Standard) und US-Börsen. Scannt Tausende Charts nach Setups: Opening-Range-Breakouts, Bull Flags, überverkaufte Aktien und Erholungen. Baut das Universum aus der offiziellen XETRA-Liste der Deutschen Börse (DAX, MDAX, SDAX, DEUTSCHLAND und alle anderen Aktien) oder aus den Nasdaq-Trader-Listen, macht einen vorbörslichen Scan der Tagesschlusskurse (20-Tage-Schlusshoch-Ausbruch, Bull Flag, 20-Tage-Durchschnitt zurückerobert, überverkauft, Erholung aus überverkauft) und einen Opening-Range-Breakout-Scan auf 5-Minuten-Kerzen und schreibt trader/watchlist.json für dt-news und dt-einstieg. Kostenlose Yahoo-Daten, Kerze für Kerze, XETRA ca. 15 Minuten verzögert. Nutze den Skill, wenn jemand sagt „scan den Markt“, „finde Setups“, „was bricht aus“, „Opening-Range-Breakouts“, „Bull Flags“, „überverkaufte Aktien“, „vorbörslicher Scan“, „bau meine Watchlist“, „DAX-Scan“, „was soll ich mir heute anschauen“, oder „scan the market“, „find me setups“, „opening range breakouts“, „pre-market scan“, am Anfang eines Handelstags vor /dt-news.

FileKindSize
SKILL.mdskill md17.6 KB
markt.pyscript13.5 KB
scan.pyscript57.2 KB
"""Märkte für das Daytrader-Skill-Paket: XETRA (Standard) und US (NYSE/Nasdaq).

Nur Standardbibliothek, ohne Zeitzonen-Dateien (Python 3.8). Diese Datei liegt
als identische Kopie in jedem Skill-Ordner, damit jeder Ordner allein läuft;
tests/test_repo.py prüft, dass alle Kopien gleich sind.

Der Markt eines Symbols folgt aus dem Symbol: SAP.DE ist XETRA, TSLA ist US.
Ohne Symbol entscheidet --market, dann "market" in trader/config.json, dann XETRA.

    import markt
    markt.use("xetra")                      # oder markt.use_for("TSLA")
    markt.to_local(utc)                     # naive Ortszeit des Marktes
    markt.session(datum)                    # (Eröffnung, Schluss) oder None
    markt.money(1234.5)                     # "1.234,50 €"
"""

import contextlib
import datetime
import re

XETRA_HOLIDAYS = {
    "2026-01-01": "Neujahr",
    "2026-04-03": "Karfreitag",
    "2026-04-06": "Ostermontag",
    "2026-05-01": "Tag der Arbeit",
    "2026-12-24": "Heiligabend",
    "2026-12-25": "1. Weihnachtstag",
    "2026-12-31": "Silvester",
    "2027-01-01": "Neujahr",
    "2027-03-26": "Karfreitag",
    "2027-03-29": "Ostermontag",
    "2027-12-24": "Heiligabend",
    "2027-12-31": "Silvester",
}
XETRA_EARLY_CLOSE = {
    "2026-12-30": "Jahresschlussbörse, letzter Handelstag des Jahres",
}
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 = {
    "2026-11-27": "Tag nach Thanksgiving",
    "2026-12-24": "Heiligabend",
    "2027-11-26": "Tag nach Thanksgiving",
}
CALENDAR_YEARS = (2026, 2027)

MARKETS = {
    "xetra": {
        "key": "xetra",
        "name": "XETRA",
        "exchange": "XETRA",
        "tz": "Europe/Berlin",
        "zone": "deutscher Zeit",
        "suffix": "Uhr",
        "open": datetime.time(9, 0),
        "close": datetime.time(17, 30),
        "early": datetime.time(14, 0),
        "holidays": XETRA_HOLIDAYS,
        "early_close": XETRA_EARLY_CLOSE,
        "currency": "EUR",
        "calendar_source": "Handelskalender der Deutschen Börse (deutsche-boerse.com, gelesen am 28.10.2026)",
        "windows": {"no_entries_before": "09:15", "no_entries_after": "17:00", "flat_by": "17:25"},
    },
    "us": {
        "key": "us",
        "name": "US (NYSE/Nasdaq)",
        "exchange": "NYSE",
        "tz": "America/New_York",
        "zone": "New Yorker Zeit",
        "suffix": "ET",
        "open": datetime.time(9, 30),
        "close": datetime.time(16, 0),
        "early": datetime.time(13, 0),
        "holidays": NYSE_HOLIDAYS,
        "early_close": NYSE_EARLY_CLOSE,
        "currency": "USD",
        "calendar_source": "NYSE-Kalender (nyse.com, gelesen am 13.10.2026)",
        "windows": {"no_entries_before": "09:45", "no_entries_after": "15:30", "flat_by": "15:55"},
    },
}
ALIASES = {"xetra": "xetra", "de": "xetra", "xetr": "xetra", "deutschland": "xetra",
           "us": "us", "usa": "us", "nyse": "us", "nasdaq": "us"}
XETRA_SUFFIX = re.compile(r"\.(DE)$", re.I)
GERMAN_SUFFIX = re.compile(r"\.(DE|F|SG|MU|DU|HM|BE|HA)$", re.I)
WEEKDAYS = ("Mo", "Di", "Mi", "Do", "Fr", "Sa", "So")
SYMBOLS = {"EUR": "\u20ac", "USD": "$"}
DEFAULT = "xetra"

_state = {"market": DEFAULT}


class MarketError(Exception):
    pass


# ---------------------------------------------------------------- which market

def norm(name):
    """'XETRA', 'de', 'US' -> 'xetra' / 'us'; anything else raises MarketError."""
    key = ALIASES.get(str(name or "").strip().lower())
    if not key:
        raise MarketError("unbekannter Markt %r: erlaubt sind xetra und us" % name)
    return key


def market_of(symbol):
    """Der Markt eines Symbols: SAP.DE -> xetra, TSLA -> us."""
    return "xetra" if XETRA_SUFFIX.search(str(symbol or "").strip()) else "us"


def use(name):
    _state["market"] = norm(name)
    return _state["market"]


def use_for(symbol):
    return use(market_of(symbol))


def current():
    return _state["market"]


def info(m=None):
    return MARKETS[norm(m) if m else _state["market"]]


def resolve(flag=None, symbols=None, cfg=None):
    """--market, dann das erste Symbol, dann config "market", dann XETRA."""
    if flag:
        return norm(flag)
    for s in symbols or ():
        if s:
            return market_of(s)
    if isinstance(cfg, dict) and cfg.get("market"):
        return norm(cfg["market"])
    return DEFAULT


@contextlib.contextmanager
def using(name):
    prev = _state["market"]
    use(name)
    try:
        yield MARKETS[_state["market"]]
    finally:
        _state["market"] = prev


@contextlib.contextmanager
def restore():
    """Stellt den Markt nach einem Befehl wieder her (main() in jedem Tool)."""
    prev = _state["market"]
    try:
        yield
    finally:
        _state["market"] = prev


# ---------------------------------------------------------------- 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 _last_sunday(year, month):
    d = datetime.date(year + (month == 12), month % 12 + 1, 1) - datetime.timedelta(days=1)
    return d - datetime.timedelta(days=(d.weekday() + 1) % 7)


def berlin_offset(utc):
    """Stunden ab UTC für Berlin: +2 in der Sommerzeit (MESZ), sonst +1 (MEZ).
    EU-Regel: vom letzten Sonntag im März 01:00 UTC bis zum letzten Sonntag im Oktober 01:00 UTC."""
    y = utc.year
    start = datetime.datetime.combine(_last_sunday(y, 3), datetime.time(1, 0))
    end = datetime.datetime.combine(_last_sunday(y, 10), datetime.time(1, 0))
    return 2 if start <= utc.replace(tzinfo=None) < end else 1


def eastern_offset(utc):
    """Stunden ab UTC für New York: -4 in der Sommerzeit, sonst -5.
    US-Regel seit 2007: zweiter Sonntag im März 2:00 bis erster Sonntag im November 2:00."""
    y = utc.year
    start = datetime.datetime.combine(_nth_sunday(y, 3, 2), datetime.time(7, 0))
    end = datetime.datetime.combine(_nth_sunday(y, 11, 1), datetime.time(6, 0))
    return -4 if start <= utc.replace(tzinfo=None) < end else -5


def offset(utc, m=None):
    return berlin_offset(utc) if info(m)["key"] == "xetra" else eastern_offset(utc)


def to_local(utc, m=None):
    """Naive UTC -> naive Ortszeit des Marktes. Nutzt nie die Zeitzone des Rechners."""
    return utc.replace(tzinfo=None) + datetime.timedelta(hours=offset(utc, m))


def to_berlin(utc):
    return utc.replace(tzinfo=None) + datetime.timedelta(hours=berlin_offset(utc))


def to_eastern(utc):
    return utc.replace(tzinfo=None) + datetime.timedelta(hours=eastern_offset(utc))


def local_to_utc(local, m=None):
    offs = (2, 1) if info(m)["key"] == "xetra" else (-4, -5)
    for off in offs:
        utc = local - datetime.timedelta(hours=off)
        if offset(utc, m) == off:
            return utc
    return local - datetime.timedelta(hours=offs[-1])


def ts_to_local(ts, m=None):
    """Unix-Sekunden -> naive Ortszeit des Marktes."""
    return to_local(datetime.datetime(1970, 1, 1) + datetime.timedelta(seconds=int(ts)), m)


def utc_now():
    return datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0, tzinfo=None)


def parse_now(text, m=None, error=MarketError):
    """ISO-Zeit -> naive UTC. Ohne Offset gilt die Ortszeit des Marktes."""
    if not text:
        return utc_now()
    t = str(text).strip().replace("Z", "+00:00")
    try:
        dt = datetime.datetime.fromisoformat(t)
    except ValueError:
        raise error('--now erwartet eine Zeit wie "2026-10-28 10:15" (%s) oder ...Z (UTC)' % info(m)["zone"])
    if dt.tzinfo is None:
        return local_to_utc(dt, m)
    return (dt - dt.utcoffset()).replace(tzinfo=None)


def parse_utc(text):
    """"2026-10-19T14:52:13Z" -> naive UTC, oder None."""
    if not text:
        return None
    try:
        dt = datetime.datetime.fromisoformat(str(text).strip().replace("Z", "+00:00"))
    except ValueError:
        return None
    if dt.tzinfo is not None:
        dt = (dt - dt.utcoffset()).replace(tzinfo=None)
    return dt


# ---------------------------------------------------------------- calendar

def trading_day(d, m=None):
    """(Handelstag?, Grund)."""
    mk = info(m)
    if d.weekday() >= 5:
        return False, "Wochenende"
    name = mk["holidays"].get(d.isoformat())
    if name:
        return False, "Börsenfeiertag %s: %s" % (mk["exchange"], name)
    return True, ""


def early_close(d, m=None):
    return info(m)["early_close"].get(d.isoformat())


def session(d, m=None):
    """(Eröffnung, Schluss) in Ortszeit, oder None an einem handelsfreien Tag."""
    mk = info(m)
    if not trading_day(d, m)[0]:
        return None
    return mk["open"], (mk["early"] if d.isoformat() in mk["early_close"] else mk["close"])


def in_calendar(d):
    return d.year in CALENDAR_YEARS


def windows(cfg=None, m=None):
    """no_entries_before / no_entries_after / flat_by für diesen Markt.
    Reihenfolge: cfg["zeiten"][markt][key], dann cfg[key], dann der Standard des Marktes."""
    mk = info(m)
    out = dict(mk["windows"])
    cfg = cfg if isinstance(cfg, dict) else {}
    for k in out:
        if k in cfg:
            out[k] = cfg[k]
    per = (cfg.get("zeiten") or {}).get(mk["key"]) or {}
    for k in out:
        if k in per:
            out[k] = per[k]
    return out


# ---------------------------------------------------------------- currency

def currency_of(symbol):
    return "EUR" if GERMAN_SUFFIX.search(str(symbol or "").strip()) else "USD"


def account_currency(cfg=None):
    """Kontowährung: cfg "account_currency", sonst USD bei alten *_usd-Schlüsseln, sonst EUR."""
    cfg = cfg if isinstance(cfg, dict) else {}
    if cfg.get("account_currency"):
        return str(cfg["account_currency"]).strip().upper()
    if any(str(k).endswith("_usd") for k in cfg):
        return "USD"
    return "EUR"


def amount(cfg, key, default=None):
    """Betrag aus der Config: "max_loss_per_trade", alt "max_loss_per_trade_usd"."""
    cfg = cfg if isinstance(cfg, dict) else {}
    for k in (key, key + "_usd", key + "_eur"):
        if cfg.get(k) is not None:
            return cfg[k]
    return default


# ---------------------------------------------------------------- yahoo symbols

def to_yahoo(sym):
    """BRK.B -> BRK-B; SAP.DE bleibt SAP.DE."""
    s = str(sym).strip().upper()
    if GERMAN_SUFFIX.search(s):
        return s
    return s.replace(".", "-")


def from_yahoo(ysym):
    s = str(ysym).strip().upper()
    if GERMAN_SUFFIX.search(s):
        return s
    return s.replace("-", ".")


# ---------------------------------------------------------------- German formats

def num(x, nd=2):
    """1234.5 -> "1.234,50"."""
    s = "{:,.{nd}f}".format(float(x), nd=nd)
    return s.replace(",", "\x00").replace(".", ",").replace("\x00", ".")


def num_short(x, nd=2):
    """Ganze Zahlen ohne Nachkommastellen: 50 -> "50", 46.88 -> "46,88"."""
    x = float(x)
    if abs(x - round(x)) < 0.005:
        return num(round(x), 0)
    return num(x, nd)


def money(x, cur=None, nd=2):
    """1234.5 -> "1.234,50 €" (Währung des aktuellen Marktes, sonst cur)."""
    cur = (cur or info()["currency"]).upper()
    return "%s %s" % (num(x, nd), SYMBOLS.get(cur, cur))


def money_short(x, cur=None):
    """50 -> "50 €", 46.88 -> "46,88 €"."""
    cur = (cur or info()["currency"]).upper()
    return "%s %s" % (num_short(x), SYMBOLS.get(cur, cur))


def price(x, nd=2):
    return num(x, nd)


def pct(x, nd=2, sign=False):
    """0.55 -> "0,55 %" (mit sign: "+0,55 %")."""
    s = num(abs(float(x)) if sign else float(x), nd)
    if sign:
        s = ("-" if float(x) < 0 else "+") + s
    return s + " %"


def clock(t):
    """datetime oder time -> "10:15"."""
    return "%02d:%02d" % (t.hour, t.minute)


def clock_label(t, m=None):
    """"10:15 Uhr" an XETRA, "10:15 ET" in New York."""
    return "%s %s" % (clock(t), info(m)["suffix"])


def clock_both(local, m=None):
    """Für US-Zeiten zusätzlich die deutsche Zeit: "10:15 ET (16:15 Uhr)"."""
    mk = info(m)
    if mk["key"] == "xetra" or not isinstance(local, datetime.datetime):
        return clock_label(local, m)
    de = to_berlin(local_to_utc(local, m))
    return "%s (%s Uhr)" % (clock_label(local, m), clock(de))


def date_de(d):
    """date -> "19.10.2026"."""
    return "%02d.%02d.%04d" % (d.day, d.month, d.year)


def day_label(d):
    """date -> "Mo 19.10.2026"."""
    return "%s %s" % (WEEKDAYS[d.weekday()], date_de(d))


def stamp(local):
    """datetime -> "Mo 19.10.2026 10:15"."""
    return "%s %s" % (day_label(local.date() if isinstance(local, datetime.datetime) else local), clock(local))


def parse_number(text):
    """"364,50" oder "364.50" -> 364.5; sonst None."""
    if text is None:
        return None
    s = str(text).strip().replace("\u20ac", "").replace("$", "").strip()
    if "," in s and "." in s:
        s = s.replace(".", "").replace(",", ".")
    elif "," in s:
        s = s.replace(",", ".")
    try:
        return float(s)
    except ValueError:
        return None
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