Trader code kit — Python and Pine Script

The entry point for S2 and S3: reads the spreadsheet export from add-on F, checks the headers and number of fields, and then cleans the r_net column. Duplicate column names, an empty header, and too many or too few fields stop the import; the script does not choose between two result columns or move data into the index. Represent an empty field with a separator, for example ;A+;;0; a truncated row is a different case. Set the separator and decimal character for the CSV variant (PL: semicolon and comma; EN: comma and point), along with the encoding: files from the add-on F generator use UTF-8, and the “CSV UTF-8” variant saved in Excel can also be read as UTF-8; an older export using the Polish code page may require cp1250. Check the save format, because the interface language alone does not determine the encoding. An empty r_net and an empty close_time_utc mean the trade has not yet closed (and is skipped); a close time without a result means an incomplete record and stops the calculations. A non-empty value that cannot be read as a number (including “NA” or a dash) stops the script and reports the record number — as does a closed trade without a close time in the add-on F format (2026-07-08 13:15), because otherwise the curve's sequence would have to be guessed.

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
ENCODING = "utf-8-sig"      # add-on F generator writes UTF-8 (BOM handled); legacy Polish-code-page CSV may need "cp1250"

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

# Read a local file and validate its shape BEFORE building a DataFrame.
# pandas.read_csv can rename duplicate headers or infer an index from extra fields.
import csv

try:
    with open(CSV_PATH, encoding=ENCODING, newline="") as source:
        reader = csv.reader(source, delimiter=CSV_SEP, strict=True)
        header = next(reader, None)
        if not header:
            raise SystemExit("Cannot read CSV: the header is empty.")
        if any(not name or name != name.strip() for name in header):
            raise SystemExit("Empty or space-padded column name — fix the CSV header.")
        duplicates = sorted({name for name in header if header.count(name) > 1})
        if duplicates:
            raise SystemExit(f"Duplicate columns: {duplicates} — resolve them in the journal.")
        rows, record_indexes = [], []
        for index, row in enumerate(reader):
            if not row:                              # a completely empty CSV record
                continue
            if len(row) != len(header):
                raise SystemExit(f"Record {index + 1}: expected {len(header)} fields, got {len(row)} "
                                 f"— check separators and quotes; no fields were discarded.")
            rows.append(row)
            record_indexes.append(index)
    df = pd.DataFrame(rows, columns=header, index=record_indexes, dtype="string").replace("", pd.NA)
except UnicodeDecodeError:
    raise SystemExit(f"Cannot decode {CSV_PATH} as {ENCODING} — check UTF-8 or legacy cp1250.") from None
except (OSError, csv.Error) as exc:
    raise SystemExit(f"Cannot read {CSV_PATH}: {exc}") from None

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 and the CSV_SEP setting.")

raw = df["r_net"]                                   # an empty result is allowed only when the close time is also empty
txt = raw.astype("string").str.strip().str.replace(DECIMAL, ".", regex=False)   # parse the column ourselves: one bad cell must not hide the readable ones
r   = pd.to_numeric(txt, errors="coerce").astype("Float64")  # avoid integer wraparound in later sums
r   = r.where(r.abs() != float("inf"))              # inf is not a valid R-multiple either
invalid = raw.notna() & r.isna()                    # filled in, but not readable as a number
if invalid.any():
    raise SystemExit(f"Invalid r_net in records {(df.index[invalid] + 1).tolist()} "
                     f"(record 1 = first row under the header) — check values and DECIMAL; "
                     f"NA, dashes and infinity are not numbers.")

blank = df.isna().all(axis=1)                       # whole row empty = unused sheet row (whole-sheet XLSX export), not a trade
df, r = df[~blank], r[~blank]
has_close = df["close_time_utc"].fillna("").str.strip().ne("")
incomplete = r.isna() & has_close
if incomplete.any():
    raise SystemExit(f"Missing r_net for closed records {(df.index[incomplete] + 1).tolist()} "
                     f"— complete the net result before calculating metrics.")
open_trades = int(r.isna().sum())
df = df.assign(r_net=r).dropna(subset=["r_net"])   # index kept = record numbers for the message below

# equity curve and drawdown need chronological order (add-on F: by close time) — a closed trade without a readable close time stops the script
close_text = df["close_time_utc"].fillna("").str.strip()
has_time = close_text.str.fullmatch(r"\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})?")
closed = pd.to_datetime(close_text.where(has_time), errors="coerce", format="ISO8601", utc=True)   # add-on F writes 2026-07-08 13:15; a fixed format keeps the check independent of row order, utc=True keeps a stray "Z"/"+00:00" suffix from crashing it
if closed.isna().any():
    raise SystemExit(f"close_time_utc not readable in records {(df.index[closed.isna()] + 1).tolist()} "
                     f"— every closed trade needs a close time in the add-on F format (2026-07-08 13:15); fix the journal, not the script.")
df = df.assign(_t=closed).sort_values("_t", kind="stable").drop(columns="_t").reset_index(drop=True)

print(f"Loaded {len(df)} closed trades ({open_trades} row(s) skipped: no close time and no r_net).")

You get: a DataFrame, df, ready for the next snippets, sorted by close time (the curve and drawdown are calculated in that order), plus the number of open trades skipped (a blank row means an entirely empty record, as in an export of a whole XLSX sheet — the script does not count these rows; a row containing data but no result or close time is skipped as not yet closed; a closed entry without a result stops the script). If it stops with a list of records, fix the indicated rows in the journal, not the script; if the whole column is affected, also check the DECIMAL constant. Record numbering starts after the header and includes empty records; a quoted field may contain a separator or a newline and still belongs to the same record. Each trade should appear once: check the trade_id identifiers before combining exports — S1 does not deduplicate the history. A date without a time is insufficient to reconstruct the sequence. A time without a time-zone marker is treated as UTC; an explicit ISO 8601 offset is converted to UTC. For identical times, the script preserves record order — establish that order in the journal, because it affects the drawdown path.

The same definitions as in prompt P5 and the spreadsheet dashboard: win rate includes break-even trades in the denominator; profit factor returns a message instead of dividing by zero; expectancy is the mean of net R (r_net); and drawdown is measured from the cumulative curve starting at 0 R (the first loss is already a drawdown — as in the formula in spreadsheet F). Run after S1. The metric definitions are shared, but the error policy differs from P5: S1 stops the analysis when a closed trade has an invalid result, whereas P5 instructs you to skip that row and count it. Compare results only after establishing which trades were included in both samples.

import math

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,
      the curve starting at 0 R (so a first loss of -1 R is already a 1 R drawdown)"""
    n = len(r)
    if n == 0:
        raise SystemExit("No valid trades — nothing to measure.")
    try:
        r = r.astype(float)
    except (TypeError, ValueError):
        raise SystemExit("Metrics require numeric net R values — run S1 first.") from None
    if not r.map(math.isfinite).all():
        raise SystemExit("Metrics require finite net R values — run S1 first.")
    wins   = r[r > 0]
    losses = r[r < 0]
    equity   = r.cumsum()
    peak     = equity.cummax().clip(lower=0)   # add-on F: MAX(0; running peak)
    drawdown = peak - equity
    try:
        total = math.fsum(r)
        pf_value = None if losses.empty else math.fsum(wins) / abs(math.fsum(losses))
    except (OverflowError, ValueError, ZeroDivisionError):
        raise SystemExit("Numeric range exceeded — check the R values; no metrics returned.") from None
    if (not equity.map(math.isfinite).all() or not drawdown.map(math.isfinite).all()
            or (pf_value is not None and not math.isfinite(pf_value))):
        raise SystemExit("Numeric range exceeded — check the R values; no metrics returned.")
    pf = "no losses in sample" if pf_value is None else round(pf_value, 2)
    return {
        "trades":         n,
        "win_rate":       round(len(wins) / n, 3),
        "profit_factor":  pf,
        "expectancy_R":   round(total / n, 3),
        "sum_R":          round(total, 2),
        "max_drawdown_R": round(drawdown.max(), 2),
    }

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

You get: six metrics for the weekly review; if there are no losses, PF is a message rather than a number. If values exceed the calculation range, the script stops the analysis instead of returning inf, NaN or an apparently zero drawdown. WR = 0.4 means 40%. PF is calculated in R, not PLN; with varying monetary risk, these results may differ. Costs are already included in r_net — S2 does not subtract them again. Do not expect an assessment of your edge from the mean alone, or simply from passing 20 or 50 trades. You will find the dashboard definitions in add-on F, and the plan for sample selection, costs and validation in add-on N.

Plots the cumulative R curve with drawdown from the peak below it, and saves a PNG next to the CSV file specified by CSV_PATH (S1), regardless of the directory from which you run the script. The curve reveals the sequence of results and clusters of losses that disappear in aggregate numbers. It is a sum of R, not the account balance in PLN or percentage equity: with varying monetary risk, it will not reproduce balance changes. This chart does not include deposits, withdrawals or the results of open positions. Run after S1.

import math
import matplotlib.pyplot as plt
from pathlib import Path

if len(df) == 0:
    raise SystemExit("No closed trades — nothing to plot.")

equity   = df["r_net"].astype(float).cumsum()
drawdown = equity.cummax().clip(lower=0) - equity   # same definition as S2 and add-on F (curve starts at 0 R)

if not equity.map(math.isfinite).all() or not drawdown.map(math.isfinite).all():
    raise SystemExit("Numeric range exceeded — check the R values; no chart saved.")

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(9, 6), sharex=True,
                               gridspec_kw={"height_ratios": [3, 1]})
x = [0, *(equity.index + 1)]                        # trade 0 = the 0 R starting point the drawdown is measured from
ax1.plot(x, [0.0, *equity.values])
ax1.set_ylabel("equity (R)")
ax1.set_title("Equity curve — cumulative net R")
ax1.grid(True, alpha=0.3)

ax2.fill_between(x, [0.0, *(-drawdown.values)], 0, alpha=0.5)
ax2.set_ylabel("drawdown (R)")
ax2.set_xlabel("trade #")
ax2.grid(True, alpha=0.3)

fig.tight_layout()
PNG_PATH = Path(CSV_PATH).with_name("equity_curve.png")   # next to the journal file, whatever the working directory
fig.savefig(PNG_PATH, dpi=150)
plt.close(fig)
print(f"Saved: {PNG_PATH}")

You get: an equity_curve.png file next to the journal; the curve starts at 0 R (trade 0), from which drawdown is measured. The lower panel shows the drawdown of cumulative R from its peak (starting at 0 R, as in S2 and spreadsheet F) over the entire history — it is not the weekly loss. Check the weekly limit from the plan (add-on E) separately, week by week, using the unit and reset rule specified in the plan.

Save as dziennik.csv (UTF-8) next to the combined S1+S2+S3 script and run it. The file contains only the columns S1 needs — the full export from add-on F (26 columns) is loaded in the same way. The last row is an open trade (empty r_net); the first two closed trades are losses, so drawdown is measured from 0 R.

trade_id;close_time_utc;setup;setup_class;r_net;error_code
2026-041;2026-07-08 13:15;wybicie-azja-londyn;A+;-1,00;5
2026-042;2026-07-09 16:40;powrot-do-sredniej;B;-1,08;3
2026-043;2026-07-10 09:05;wybicie-azja-londyn;A+;1,83;0
2026-044;2026-07-13 12:20;wybicie-azja-londyn;B;0,00;0
2026-045;2026-07-14 14:30;powrot-do-sredniej;C;2,40;0
2026-046;;wybicie-azja-londyn;B;;

Expected output (Python 3.12.10, pandas 3.0.5, matplotlib 3.11.1; run on 17 September 2026):

Loaded 5 closed trades (1 row(s) skipped: no close time and no r_net).
          trades: 5
        win_rate: 0.4
   profit_factor: 2.03
    expectancy_R: 0.43
           sum_R: 2.15
  max_drawdown_R: 2.08
Saved: equity_curve.png

Calculation to check by hand: wins of 1.83 + 2.40 = 4.23 R, losses of 1.00 + 1.08 = 2.08 R → PF 2.03; total 2.15 R / 5 = 0.43 R; the curve −1.00 → −2.08 → −0.25 → −0.25 → 2.15, with a starting peak of 0 R → drawdown of 2.08 R (without the 0 R point, it would be 1.08 R — this is the distinction behind the definition in add-on F). The output refers to this exact file and the stated versions; if it differs, check the data (separator, decimal character, encoding, row order), the constants in S1, the code, and the package versions, in that order.

Volume in lots for a stop distance of k × ATR: the risk amount comes from capital and percentage, the distance from ATR, and the volume is rounded DOWN to your account's lot step (the lot_step and min_lot parameters, both defaulting to 0.01) — so that PLANNED risk does not exceed the budget. The actual loss can be greater: this calculation excludes slippage, gaps through the stop, spread, commission and swap. Capital and pip value must be in the same account currency; separately check the maximum volume and margin requirement in the specification. Enter ATR in pips (EURUSD 0.0080 → 80; USDJPY 0.80 → 80; pip size is covered in the pair profile, add-on B); the pip value for 1 lot is in the instrument specification (or you can calculate it using the calculator in add-on C).

import math
from decimal import Decimal
from fractions import Fraction

def atr_position_size(capital, risk_pct, atr_pips, atr_mult, pip_value_per_lot,
                      lot_step=0.01, min_lot=0.01):
    """Volume in lots for a stop of atr_mult × ATR.
    atr_pips: ATR in PIPS, not in price units (EURUSD ATR 0.0080 -> 80; USDJPY ATR 0.80 -> 80 — pip size of the pair).
    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).
    lot_step / min_lot: volume step and minimum of YOUR account (0.01 is common, not universal).
    Rounds DOWN to multiples of lot_step, measured from zero. Fraction arithmetic
    preserves the decimal inputs without depending on the global Decimal precision.
    Planned risk is not the maximum loss: slippage, gaps, spread and swap are not in this model."""
    inputs = (capital, risk_pct, atr_pips, atr_mult, pip_value_per_lot, lot_step, min_lot)
    if any(isinstance(x, bool) or not isinstance(x, (int, float, Decimal)) for x in inputs):
        raise ValueError("Use numeric values, not text or booleans (Python decimals use a dot).")
    decimals = tuple(Decimal(str(x)) for x in inputs)
    if not all(x.is_finite() and x > 0 for x in decimals):
        raise ValueError("All inputs must be finite, positive numbers.")
    c, p, a, k, v, step, minimum = map(Fraction, decimals)
    if p > 100:
        raise ValueError("risk_pct is a percentage of capital (1.0 = 1%).")
    risk_amount = c * p / 100
    sl_pips     = a * k
    lots        = math.floor(risk_amount / (sl_pips * v * step)) * step
    if lots < minimum:
        return {"warning": "No admissible volume for this lot_step and min_lot within the risk budget."}
    exact = {"risk_amount": risk_amount, "sl_pips": sl_pips,
             "lots": lots, "planned_risk": lots * sl_pips * v}
    try:
        result = {key: float(value) for key, value in exact.items()}
    except OverflowError:
        raise ValueError("Inputs exceed the output numeric range.") from None
    if not all(math.isfinite(value) and value > 0 for value in result.values()):
        raise ValueError("Inputs exceed the output numeric range.")
    return result  # floats for display; no extra rounding of the stop or money values


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, 'planned_risk': 96.0}

You get: lots rounded down to the step and the resulting PLANNED risk amount (in the model without costs, ≤ the budget; the actual loss may be greater). The step is measured from zero; check that your account uses this volume grid. The stop and monetary amounts are not rounded further: for example, ATR of 0.26 pips × 1.25 gives 0.325 pips, not 0.3. The output is returned as float values for reading, while the number of lot steps is calculated using exact fractions; the instrument's minimum price increment must still be checked separately. If you adjust the stop to that increment, recalculate the volume. Do not expect: a decision on whether to enter — the sizer calculates “how much”, never “whether”.

A volatility-awareness tool (an intraday indicator): on live bars, it shows what percentage of the daily ATR the market has already “used up”, and alerts you when a threshold is crossed — a moment to consult the plan, not to chase. Daily data is retrieved without lookahead (without future values); on historical bars, request.security holds the last confirmed daily value until the end of the next D period, with that period's new result appearing on its final intraday bar. In real time, it retrieves the developing range and ATR of the current D candle, so earlier readings may change after a reload (repainting). A day means the data provider's D candle, not a calendar day in Europe/Warsaw. The ATR in the denominator also changes during the day; 100% is not a limit on how far price can move. This method cannot reconstruct today's successive threshold crossings on historical bars.

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

if not timeframe.isintraday
    runtime.error("Use a time-based intraday chart below 1D.")

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

// Historical: last confirmed D value, updated at the END of each D period.
// Realtime: developing D values; elapsed realtime readings can repaint after reload.
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(warnPct, "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.")

You get: a panel below the chart and an alert condition — create the alert yourself in the platform after adding the indicator, selecting “Range reached % of ATR”. Use standard time-based intraday candles; Heikin Ashi/Renko data may have different characteristics. A missing reading (na) means the required ATR or data is unavailable, not 0%. The condition requires a move from a value ≤ the threshold to a value > the threshold: simply staying above it does not trigger another alert. “Once Per Bar Close” restricts alerts to the intraday candle close, but does not confirm the entire D candle. Recreate the alert after changing the parameters. Do not expect: a directional signal — a high reading says “the move has already happened”; the playbook tells you what to do about it.

Section 3 of the plan (add-on E), drawn on the chart: highlights the hours when you ARE ALLOWED to open positions, and alerts you when the window closes. Enter the times in the Europe/Warsaw time zone — the IANA identifier accounts for CET/CEST. By default, the windows apply Monday to Friday; an option extends them to all days. The highlighting confirms only the time specified in the plan, not the other entry conditions. Use standard time-based intraday candles.

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

if not timeframe.isintraday
    runtime.error("Use a time-based intraday chart below 1D.")

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

weekdaysOnly = input.bool(true, "Monday to Friday only")
days = weekdaysOnly ? ":23456" : ":1234567"

inWin = not na(time(timeframe.period, win1 + days, tz)) or not na(time(timeframe.period, win2 + days, 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).")

You get: background shading during trading hours and an alert condition for the window's close (“Plan window closed” — create the alert in the platform after adding the indicator). The alert detects the first candle outside the window following a candle inside it, so it does not guarantee a notification at the exact closing time: without a new candle and a data update, it performs no check. Use a timeframe whose opens and closes align with the window boundaries. For example, on M15, with a 09:00–12:00 window and a 12:00 candle available, the shading ends at 12:00 and the condition is active on that first candle outside the window. “Once Per Bar” may notify you on its first update; “Once Per Bar Close” only at its close. Overlapping windows form a union: the end of the first does not close the second. Recreate the alert after changing the times. Do not expect: order blocking — the indicator reminds you of the plan; your pre-trade checklist enforces it.