Zestaw kodu tradera — Python i Pine Script

Punkt wejścia dla S2 i S3: czyta eksport arkusza z dodatku F, waliduje nagłówki i czyści kolumnę r_net. Ustaw separator i przecinek dziesiętny zgodnie z wariantem CSV (PL: średnik i przecinek, EN: przecinek i kropka).

import pandas as pd

CSV_PATH = "dziennik.csv"   # journal export (add-on F structure)
CSV_SEP  = ";"              # ";" for PL-locale CSV, "," for EN
DECIMAL  = ","              # "," for PL-locale CSV, "." for EN

REQUIRED = ["r_net", "setup", "setup_class", "error_code"]

df = pd.read_csv(CSV_PATH, sep=CSV_SEP, decimal=DECIMAL)

missing = [c for c in REQUIRED if c not in df.columns]
if missing:
    raise SystemExit(f"Missing columns: {missing} — check headers against add-on F.")

df["r_net"] = pd.to_numeric(df["r_net"], errors="coerce")
skipped = int(df["r_net"].isna().sum())
df = df.dropna(subset=["r_net"]).reset_index(drop=True)

print(f"Loaded {len(df)} trades ({skipped} rows skipped: empty or invalid r_net).")

Dostaniesz: ramkę danych df gotową dla kolejnych fragmentów plus informację, ile wierszy odpadło. Jeśli odpada więcej niż kilka — napraw dziennik, nie skrypt.

Te same definicje co w prompcie P5 i dashboardzie arkusza: win rate z break-even w mianowniku, profit factor z komunikatem zamiast dzielenia przez zero, expectancy jako średnia z r_net, obsunięcie z krzywej skumulowanej. Uruchamiaj po S1.

def metrics(r):
    """Core journal metrics on a series of net R-multiples.
    Definitions (same as add-on F dashboard):
    - win rate: trades with r > 0 over ALL valid trades (break-even stays in denominator)
    - profit factor: sum of positive r over abs(sum of negative r)
    - expectancy: arithmetic mean of r (net of costs)
    - max drawdown: max drop of the cumulative R curve from its running peak"""
    n = len(r)
    if n == 0:
        raise SystemExit("No valid trades — nothing to measure.")
    wins   = r[r > 0]
    losses = r[r < 0]
    equity   = r.cumsum()
    drawdown = equity.cummax() - equity
    pf = "no losses in sample" if losses.empty else round(wins.sum() / abs(losses.sum()), 2)
    return {
        "trades":         n,
        "win_rate":       round(len(wins) / n, 3),
        "profit_factor":  pf,
        "expectancy_R":   round(r.mean(), 3),
        "sum_R":          round(r.sum(), 2),
        "max_drawdown_R": round(drawdown.max(), 2),
    }

for key, value in metrics(df["r_net"]).items():
    print(f"{key:>16}: {value}")

Dostaniesz: sześć liczb do przeglądu tygodniowego. Nie oczekuj: oceny systemu na 20 transakcjach — interpretacja progów jest w tabeli dashboardu dodatku F.

Rysuje krzywą skumulowanego R i pod nią obsunięcie od szczytu, zapisuje PNG obok skryptu. Krzywa kapitału mówi o charakterze systemu więcej niż każda pojedyncza liczba — zwłaszcza o klastrach strat. Uruchamiaj po S1.

import matplotlib.pyplot as plt

equity   = df["r_net"].cumsum()
drawdown = equity.cummax() - equity

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(9, 6), sharex=True,
                               gridspec_kw={"height_ratios": [3, 1]})
ax1.plot(equity.index + 1, equity.values)
ax1.set_ylabel("equity (R)")
ax1.set_title("Equity curve — cumulative net R")
ax1.grid(True, alpha=0.3)

ax2.fill_between(drawdown.index + 1, -drawdown.values, 0, alpha=0.5)
ax2.set_ylabel("drawdown (R)")
ax2.set_xlabel("trade #")
ax2.grid(True, alpha=0.3)

fig.tight_layout()
fig.savefig("equity_curve.png", dpi=150)
print("Saved: equity_curve.png")

Dostaniesz: plik equity_curve.png. Porównaj maksimum dolnego panelu z limitem tygodniowym z planu (dodatek E) — historia głębsza niż limit oznacza niespójny sizing.

Wolumen w lotach dla stopa o szerokości k × ATR: kwota ryzyka z kapitału i procentu, dystans z ATR, zaokrąglenie W DÓŁ do 0,01 lota — żeby faktyczne ryzyko nigdy nie przekroczyło planu. Wartość pipsa dla 1 lota znajdziesz w specyfikacji instrumentu (albo policzysz kalkulatorem z dodatku C).

import math

def atr_position_size(capital, risk_pct, atr_pips, atr_mult, pip_value_per_lot):
    """Volume in lots for a stop of atr_mult × ATR.
    pip_value_per_lot: value of 1 pip for 1.00 lot, in account currency
    (e.g. ~10 USD for EURUSD on a USD account — check instrument specs).
    Rounds DOWN to 0.01 lot so real risk never exceeds the plan."""
    if min(capital, risk_pct, atr_pips, atr_mult, pip_value_per_lot) <= 0:
        raise ValueError("All inputs must be positive numbers.")
    risk_amount = capital * risk_pct / 100.0
    sl_pips     = atr_mult * atr_pips
    lots_exact  = risk_amount / (sl_pips * pip_value_per_lot)
    lots        = math.floor(lots_exact * 100) / 100
    if lots < 0.01:
        return {"warning": "Risk too small for 0.01 lot — widen capital or accept higher %."}
    return {"risk_amount": round(risk_amount, 2),
            "sl_pips":     round(sl_pips, 1),
            "lots":        lots,
            "real_risk":   round(lots * sl_pips * pip_value_per_lot, 2)}

print(atr_position_size(capital=10_000, risk_pct=1.0,
                        atr_pips=80, atr_mult=1.5, pip_value_per_lot=10.0))
# {'risk_amount': 100.0, 'sl_pips': 120.0, 'lots': 0.08, 'real_risk': 96.0}

Dostaniesz: loty plus RZECZYWISTĄ kwotę ryzyka po zaokrągleniu (zawsze ≤ plan). Nie oczekuj: decyzji, czy wchodzić — sizer liczy „ile", nigdy „czy".

Narzędzie świadomości zmienności: pokazuje, jaki procent dziennego ATR rynek już „zużył", i alarmuje po przekroczeniu progu — moment na pytanie z planu, nie na pogoń. Dane dzienne pobierane bez lookahead (wzorzec z przeglądu P3).

//@version=6
indicator("Daily range vs ATR (awareness tool)", overlay=false)

atrLen  = input.int(14, "ATR length", minval=2)
warnPct = input.int(80, "Alert when day range reaches % of ATR", minval=10, maxval=200)

// higher-timeframe data WITHOUT lookahead — the pattern prompt P3 checks for
dayHigh = request.security(syminfo.tickerid, "D", high,            lookahead=barmerge.lookahead_off)
dayLow  = request.security(syminfo.tickerid, "D", low,             lookahead=barmerge.lookahead_off)
dayAtr  = request.security(syminfo.tickerid, "D", ta.atr(atrLen),  lookahead=barmerge.lookahead_off)

rangePct = dayAtr > 0 ? 100.0 * (dayHigh - dayLow) / dayAtr : na

plot(rangePct, "Day range as % of ATR", linewidth=2)
hline(100, "100% of ATR")
hline(80,  "Default alert level", linestyle=hline.style_dotted)

alertcondition(ta.crossover(rangePct, warnPct),
     title="Range reached % of ATR",
     message="Daily range reached your % of ATR — re-read the plan before any new entry.")

Dostaniesz: panel pod wykresem plus alert platformy. Nie oczekuj: sygnału kierunku — wysoki odczyt mówi „ruch już się odbył", a co z tym zrobić, mówi playbook.

Sekcja 3 planu (dodatek E) narysowana na wykresie: podświetla godziny, w których WOLNO otwierać pozycje, i alarmuje, gdy okno się zamyka. Godziny podajesz w strefie Europe/Warsaw — wskaźnik sam dba o zmiany czasu.

//@version=6
indicator("Trading-plan session windows", overlay=true)

tz   = input.string("Europe/Warsaw", "Time zone of the windows")
win1 = input.session("0900-1200", "Window 1")
win2 = input.session("1400-1700", "Window 2")

inWin = not na(time(timeframe.period, win1, tz)) or not na(time(timeframe.period, win2, tz))

bgcolor(inWin ? color.new(color.teal, 88) : na, title="Inside a plan window")

windowJustClosed = inWin[1] and not inWin
alertcondition(windowJustClosed,
     title="Plan window closed",
     message="Your trading window just closed — manage open positions only, no new entries (plan, section 3).")

Dostaniesz: tło w godzinach handlu i alert na zamknięcie okna. Nie oczekuj: blokady zleceń — wskaźnik przypomina o planie; egzekwuje go Twoja checklista pre-trade.