atm-curs-dl/gen/strategii/buy_doji_transe.py

"""Buy Doji — intrarea în trei tranșe, pe același trade ca restul capitolului.

Citește `gen/strategii/buy_doji_transe.spec.txt`. Barele vin din
`buy_doji_ansamblu.serie()`: doji 50.10/49.25, confirmare cu close 50.40,
stop 49.20. Nivelurile de 1/3 și 1/2 se calculează din corpul candelei de
confirmare (open 49.90 → close 50.40), nu se scriu de mână.

Lecția: împărțind intrarea în trei, prețul mediu scade de la 50.40 la
50.26, deci riscul pe acțiune de la 1.20 la 1.06 — dacă prețul revine.
Bara de după confirmare coboară la 50.10 și umple ambele ordine limită.
"""
import re
import sys
from pathlib import Path

sys.path.insert(0, "/workspace/atm-curs-dl")
sys.path.insert(0, str(Path(__file__).parent))
from svg_candles import Chart, Level, Zone, Arrow                  # noqa: E402
from buy_doji_ansamblu import serie, DOJI, CONF, DOJI_L, ENTRY, SL, TP1, R  # noqa: E402

OUT = Path(__file__).with_suffix(".svg")
S = 12                                 # prima bară arătată (zoom pe fereastra de intrare)
GREEN, RED, ORANGE, BLUE, GREY = "#188a3e", "#c00", "#b06000", "#1a5fb4", "#555"
W, SCALE = 930, 100.0

cds = serie()[S:20]                    # până la bara care atinge ținta
d, cf = DOJI - S, CONF - S             # doji, confirmare (indici locali)
op, T1 = cds[cf].o, cds[cf].c          # corpul candelei de confirmare
corp = round(T1 - op, 2)
T2, T3 = round(T1 - corp / 3, 2), round(T1 - corp / 2, 2)
MED = round((T1 + T2 + T3) / 3, 2)
RISC_MED, RISC_CLOSE = round(MED - SL, 2), round(T1 - SL, 2)
TP_MED = round(MED + RISC_MED, 2)     # ținta de 1R socotită de la prețul mediu
retest = cds[cf + 1]

# --- aserțiuni ------------------------------------------------------------------
assert (op, T1) == (49.90, ENTRY) and corp == 0.50, (op, T1, corp)
assert (T2, T3) == (50.23, 50.15), (T2, T3)
assert MED == 50.26 and RISC_MED == 1.06 and RISC_CLOSE == R == 1.20
assert retest.l <= T3 < T2, "bara de după confirmare nu umple ambele ordine"
assert round(retest.l, 2) == 50.10, retest.l
assert min(c.l for c in cds[cf - 3:cf + 1]) == DOJI_L and round(DOJI_L - 0.05, 2) == SL
assert round(T1 + RISC_CLOSE, 2) == TP1
# ținta de 1R vine mai devreme dacă prețul mediu de intrare e mai bun
assert TP_MED == 51.32 == round(MED + RISC_MED, 2) and TP_MED < TP1
assert next(i for i in range(cf + 1, len(cds)) if cds[i].h >= TP1) == len(cds) - 1
# măsurat pe toată candela (nu doar pe corp) 1/2 iese tot T3; 1/3 iese 50.28
hi, lo = cds[cf].h, cds[cf].l
assert round(hi - (hi - lo) / 3, 2) == 50.28 and round((hi + lo) / 2, 2) == T3
print(f"transe: T1 {T1:.2f}  T2 {T2:.2f}  T3 {T3:.2f}  medie {MED:.2f}  "
      f"risc {RISC_MED:.2f} (față de {RISC_CLOSE:.2f})  retest low {retest.l:.2f}")


def dy_sub(price, rand):
    """Săgeata pleacă din nivel și coboară sub linia stopului, pe rândul `rand`."""
    return (price - SL) * SCALE + rand


ch = Chart(
    candles=cds,
    levels=[Level(TP1, "ținta 1: 51.60 = 1R față de close", GREEN, "2 2"),
            Level(TP_MED, f"ținta 1: {TP_MED:.2f} = 1R față de prețul mediu {MED:.2f}", BLUE, "2 2"),
            Level(SL, "stopul: 49.20", RED, "4 3", "left")],
    zones=[Zone(cf, cf, "", GREEN, p_top=T1, p_bot=op)],
    arrows=[
        Arrow(cf, "1/3 la close 50.40\nca să nu ratezi trade-ul dacă pleacă fără tine",
              where="right", price=T1, color=GREEN, dx=150, dy=dy_sub(T1, 40)),
        Arrow(cf, "1/3 cu ordin limită la 50.23 (o treime din corp)\nmai ieftin, dacă prețul revine",
              where="right", price=T2, color=ORANGE, dx=150, dy=dy_sub(T2, 74)),
        Arrow(cf, "1/3 cu ordin limită la 50.15 (jumătatea corpului)\nși mai ieftin",
              where="right", price=T3, color=ORANGE, dx=150, dy=dy_sub(T3, 108)),
        Arrow(cf - 1, "media mai bună coboară ținta:\nieși la 51.32, nu la 51.60",
              where="above", price=TP_MED, color=BLUE, dx=150),
        Arrow(cf + 1, "retestul: prețul revine la 50.10\nși umple amândouă ordinele limită",
              where="below", price=retest.l, color=BLUE, dx=-150, dy=20),
    ],
    scale=SCALE, gap=30, body_w=10, left=56, width=W,
    title="Intrarea în trei tranșe — același trade (doji 50.10 / 49.25)",
    caption="Paranteza de pe candela de confirmare e corpul ei (49.90 → 50.40): pe el se măsoară 1/3 și 1/2. Stopul e unul singur. Exemplu construit.",
)
svg = ch.render()
OFF = (float(re.search(r'<line x1="24" y1="([\d.]+)"', svg).group(1))
       - ch._y(ch.levels[0].price))    # render() mută `top` și îl restaurează


# același lucru pe orizontală: render() lărgește pânza și mută `left` când un
# text de săgeată ar ieși în stânga. Offsetul se citește din prima candelă.
OFF_X = (float(re.search(r'<line x1="([\d.]+)"[^>]*stroke="#1a1a1a"', svg).group(1))
         - ch._cx(0))


def Y(p):
    return ch._y(p) + OFF


def x(i):
    return ch._cx(i) + OFF_X
ex = []
# paranteza corpului, în stânga candelei de confirmare, cu diviziunile 1/3 și 1/2
xb = x(cf) - 17
ex.append(f'<polyline points="{xb + 5:.1f},{Y(T1):.1f} {xb:.1f},{Y(T1):.1f} {xb:.1f},{Y(op):.1f} '
          f'{xb + 5:.1f},{Y(op):.1f}" fill="none" stroke="{GREY}" stroke-width="2"/>')
# fără etichetă lângă paranteză: oriunde lângă candele s-ar suprapune peste ele
# sau peste liniile săgeților. O numește legenda de sub grafic.
# nivelurile de tranșă, ca segmente scurte peste candela de confirmare
for p, col in ((T1, GREEN), (T2, ORANGE), (T3, ORANGE)):
    dash = "" if p == T1 else ' stroke-dasharray="3 3"'
    ex.append(f'<line x1="{xb:.1f}" y1="{Y(p):.1f}" x2="{x(cf) + 8:.1f}" y2="{Y(p):.1f}" '
              f'stroke="{col}" stroke-width="1.5"{dash}/>')
# unde se umple fiecare tranșă: T1 la close, T2 și T3 pe low-ul barei următoare
for i, p, col in ((cf, T1, GREEN), (cf + 1, T2, ORANGE), (cf + 1, T3, ORANGE)):
    ex.append(f'<circle cx="{x(i):.1f}" cy="{Y(p):.1f}" r="4" fill="#fff" '
              f'stroke="{col}" stroke-width="2"/>')
# cele două paranteze de risc, la dreapta: tot la close vs cu tranșe
for xp, hi_p, txt, col in ((x(len(cds) - 1) + 40, T1,
                            f"risc {RISC_CLOSE:.2f} pe acțiune (tot la close)", RED),
                           (x(len(cds) - 1) + 290, MED,
                            f"risc {RISC_MED:.2f} pe acțiune (cu tranșe, preț mediu {MED:.2f})", BLUE)):
    y1, y2 = Y(hi_p), Y(SL)
    ex.append(f'<polyline points="{xp - 5:.1f},{y1:.1f} {xp:.1f},{y1:.1f} {xp:.1f},{y2:.1f} '
              f'{xp - 5:.1f},{y2:.1f}" fill="none" stroke="{col}" stroke-width="1.5"/>')
    ex.append(f'<text x="{xp + 6:.1f}" y="{(y1 + y2) / 2 + 4:.1f}" fill="{col}" '
              f'style="font-weight:bold">{txt}</text>')
body = svg.rsplit("</svg>", 1)[0].rstrip()
svg = "\n  ".join([body, *ex]) + "\n</svg>"
vw, vh = (float(v) for v in re.search(r'viewBox="0 0 ([\d.]+) ([\d.]+)"', svg).groups())
for tx, attrs, txt in re.findall(r'<text x="([-\d.]+)"([^>]*)>(.*?)</text>', svg):
    ty = float(re.search(r'y="([-\d.]+)"', attrs).group(1))
    w = len(txt) * 6.2
    x0 = float(tx) - (w if 'text-anchor="end"' in attrs else w / 2 if 'middle' in attrs else 0)
    assert 0 <= x0 and x0 + w <= vw and 0 <= ty <= vh, f"text în afara pânzei: {txt!r}"
assert "\n\n" not in svg, "linie goală în SVG"
OUT.write_text(svg, encoding="utf-8")
print(f"scris {OUT} ({vw:.0f}x{vh:.0f})")