"""
Generator de diagrame de candele pentru summaries/.
Motivul existenței: diagramele desenate de mână ies la scară greșită. În
`01_MODUL_1/05_patternuri_candele.md` ținta de 2R era desenată la distanța
de 1R față de intrare (75 px/unitate în jos, 41 px/unitate în sus), iar la
Marubozu eticheta de open era pusă deasupra celei de close — axa de preț
inversată. Aici coordonatele se calculează din prețuri, deci scara e
corectă prin construcție.
Convenție: un singur `scale` (px per unitate de preț) pentru tot desenul.
Două stiluri de desen:
1. **Ilustrativ** (implicit, `gap=92`, 3-6 candele): pentru definiții de
pattern-uri, unde contează forma unei candele, nu trendul.
2. **Grafic real** (`gap=14`, `body_w=9`, 25-45 de candele, `vol_h=70`):
serie continuă de preț cu panou de volum dedesubt, ca pe TradingView.
Userul a cerut explicit stilul ăsta pentru orice diagramă unde trebuie
să se vadă un trend sau relația preț-volum. Etichetează candelele care
contează cu `marks`, nu cu `tag` — la 40 de candele etichetele per
candelă se suprapun.
"""
from dataclasses import dataclass, field
@dataclass
class Candle:
o: float
h: float
l: float
c: float
tag: str = "" # eticheta de sub candelă (stil ilustrativ)
note: str = "" # linie de text în blocul de sub grafic
color: str | None = None # implicit: verde dacă c >= o
vol: float | None = None # volumul barei, pentru panoul de volum
@dataclass
class Level:
price: float
text: str
color: str = "#1a5fb4"
dash: str = "4 3"
label_at: str = "right" # "right" | "left" — unde stă eticheta
@dataclass
class Mark:
"""Etichetă ancorată pe o candelă anume, pentru serii lungi."""
i: int # indexul candelei
text: str
color: str = "#1a5fb4"
where: str = "above" # "above" | "below" — față de candelă
dy: float = 0.0 # ajustare fină, dacă se suprapune cu altceva
@dataclass
class MA:
"""Medie mobilă simplă, calculată din close-uri."""
period: int
color: str = "#b06000"
dash: str = ""
text: str = ""
@dataclass
class Chart:
candles: list[Candle]
levels: list[Level] = field(default_factory=list)
marks: list[Mark] = field(default_factory=list)
mas: list[MA] = field(default_factory=list)
scale: float = 60.0 # px per unitate de preț
width: int = 620
body_w: int = 26
gap: int = 92 # distanță între candele
left: int = 64 # x-ul primei candele
top: int = 34 # spațiu deasupra celui mai mare preț
label_gap: int = 34 # spațiu sub cea mai joasă candelă pentru etichete
caption: str = ""
trend: str = "" # "down" / "up" / "" — segment de trend înainte
vol_h: float = 0.0 # înălțimea panoului de volum (0 = fără panou)
vol_gap: float = 26.0 # spațiu între panoul de preț și cel de volum
vol_label: str = "volum"
title: str = "" # ex. "SPY — daily"
def _y(self, price: float) -> float:
return self.top + (self._pmax - price) * self.scale
def _cx(self, i: int) -> float:
return self.left + i * self.gap
def render(self) -> str:
prices = [p for c in self.candles for p in (c.o, c.h, c.l, c.c)]
prices += [lv.price for lv in self.levels]
self._pmax, pmin = max(prices), min(prices)
if self.title:
self.top += 22
# segmentul de trend iese din zona candelelor: rezervă loc pentru el,
# altfel se suprapune peste etichete sau peste marginea desenului
if self.trend == "down":
self.top += 56
body_bottom = self.top + (self._pmax - pmin) * self.scale
extra = 62 if self.trend == "up" else 0
panel_bottom = body_bottom + extra
vols = [c.vol for c in self.candles if c.vol is not None]
vol_top = vol_base = None
if self.vol_h and vols:
vol_top = panel_bottom + self.vol_gap
vol_base = vol_top + self.vol_h
panel_bottom = vol_base
n_notes = sum(1 for c in self.candles if c.note)
tags = any(c.tag for c in self.candles)
height = (panel_bottom + (self.label_gap if tags else 18)
+ 17 * n_notes + (24 if self.caption else 8))
out = [f'")
return "\n ".join(out).replace("\n ", "\n")
def walk(start: float, moves: list[tuple[float, float, float]],
vols: list[float] | None = None) -> list[Candle]:
"""Construiește o serie continuă de candele dintr-un preț de start.
Fiecare `move` e (delta_close, wick_sus, wick_jos) față de open-ul barei,
iar open-ul fiecărei bare e close-ul barei anterioare — deci seria nu are
goluri artificiale, exact ca pe un grafic real.
"""
out, o = [], start
for i, (dc, wu, wd) in enumerate(moves):
c = o + dc
h = max(o, c) + wu
l = min(o, c) - wd
out.append(Candle(o, h, l, c, vol=(vols[i] if vols else None)))
o = c
return out
def from_closes(closes: list[float], wick: float = 0.0,
wicks: list[tuple[float, float]] | None = None,
vols: list[float] | None = None,
start: float | None = None) -> list[Candle]:
"""Serie continuă de candele dintr-o listă de close-uri.
Open-ul fiecărei bare = close-ul precedentei, deci structura (swing
high-uri, swing low-uri) e exact cea din lista de close-uri — util când
diagrama trebuie să susțină o afirmație despre niveluri.
"""
out = []
o = start if start is not None else closes[0]
for i, c in enumerate(closes):
wu, wd = wicks[i] if wicks else (wick, wick)
out.append(Candle(o, max(o, c) + wu, min(o, c) - wd, c,
vol=(vols[i] if vols else None)))
o = c
return out
def selftest():
"""Scara trebuie să fie aceeași oriunde, iar volumul proporțional."""
ch = Chart(candles=[Candle(o=63.05, h=63.30, l=62.10, c=63.30)],
levels=[Level(62.05, "SL"), Level(63.35, "entry"), Level(65.95, "TP 2R")],
scale=60)
svg = ch.render()
ys = {lv.price: ch._y(lv.price) for lv in ch.levels}
risc = ys[62.05] - ys[63.35] # px, în jos
castig = ys[63.35] - ys[65.95] # px, în sus
assert abs(castig / risc - 2.0) < 0.01, f"2R desenat la {castig/risc:.2f}R"
assert " min(c.l for c in ser[3:5]), \
"al doilea picior ar trebui să fie mai jos"
print("selftest ok: 2R la exact 2R, serie fără goluri, volum proporțional")
if __name__ == "__main__":
selftest()