First commit
This commit is contained in:
+285
@@ -0,0 +1,285 @@
|
||||
"""Demo mode: the bot runs on its own, with fake money and no broker.
|
||||
|
||||
DEMO_DATA=real (default):
|
||||
- Real candles from Yahoo Finance for every instrument in config, polled every few minutes.
|
||||
- Real news headlines, judged by DeepSeek if a key is set, otherwise by a keyword score.
|
||||
DEMO_DATA=simulated:
|
||||
- Made-up prices (random walk with trending phases) and made-up news. Works offline,
|
||||
and runs fast, so you can see many trades in a few minutes.
|
||||
|
||||
In both: the same strategy as pine/trend_strategy.pine runs in Python on each new candle,
|
||||
and every order goes to the built-in paper broker.
|
||||
"""
|
||||
import math
|
||||
import random
|
||||
import threading
|
||||
import time
|
||||
from collections import deque
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
from .config import INSTRUMENTS
|
||||
from .sentiment import Verdict
|
||||
from .strategy import DEFAULT, adx, atr, diagnose, ema, signal # noqa: F401 (re-exported: the rules live in strategy.py)
|
||||
|
||||
# Rough starting levels and volatility per candle. Simulated, not live data.
|
||||
START = {"BTCUSD": 67000, "ETHUSD": 3500, "SOLUSD": 180,
|
||||
"ASML": 700, "ADYEN": 1400, "INGA": 18, "PHIA": 25, "MC": 600, "TTE": 55,
|
||||
"SAP": 220, "SIE": 200, "ALV": 330, "SHEL": 27, "AZN": 120, "HSBA": 8,
|
||||
"SPY": 600, "QQQ": 520, "AAPL": 230, "MSFT": 450, "NVDA": 180}
|
||||
|
||||
FAST, SLOW = DEFAULT.fast, DEFAULT.slow
|
||||
|
||||
|
||||
@dataclass
|
||||
class Series:
|
||||
symbol: str
|
||||
vol: float # stdev of returns per candle
|
||||
price: float
|
||||
regime: float = 0.0 # drift per candle
|
||||
regime_left: int = 0
|
||||
closes: deque = field(default_factory=lambda: deque(maxlen=300))
|
||||
highs: deque = field(default_factory=lambda: deque(maxlen=300))
|
||||
lows: deque = field(default_factory=lambda: deque(maxlen=300))
|
||||
volumes: deque = field(default_factory=lambda: deque(maxlen=300))
|
||||
in_position: bool = False
|
||||
trail: float | None = None
|
||||
last_ts: int = 0 # real mode: timestamp of the newest closed candle
|
||||
currency: str = ""
|
||||
error: str = ""
|
||||
|
||||
def step(self, rng: random.Random):
|
||||
if self.regime_left <= 0: # pick a new market phase: uptrend, downtrend or sideways
|
||||
kind = rng.choices(["up", "down", "flat"], [0.38, 0.30, 0.32])[0]
|
||||
strength = rng.uniform(0.25, 0.6) * self.vol
|
||||
self.regime = {"up": strength, "down": -strength, "flat": 0.0}[kind]
|
||||
self.regime_left = rng.randint(40, 140)
|
||||
self.regime_left -= 1
|
||||
ret = self.regime + rng.gauss(0, self.vol)
|
||||
o = self.price
|
||||
c = max(o * math.exp(ret), 0.01)
|
||||
wick = abs(rng.gauss(0, self.vol * 0.6))
|
||||
# Volume rises with the size of the move, plus random spikes.
|
||||
v = rng.lognormvariate(0, 0.35) * (1 + 0.8 * abs(ret) / self.vol)
|
||||
if rng.random() < 0.08:
|
||||
v *= rng.uniform(1.5, 2.5)
|
||||
self.append(max(o, c) * (1 + wick), min(o, c) * (1 - wick), c, v)
|
||||
|
||||
def append(self, high, low, close, volume, ts=None):
|
||||
self.highs.append(high)
|
||||
self.lows.append(low)
|
||||
self.closes.append(close)
|
||||
self.volumes.append(volume)
|
||||
self.price = close
|
||||
if ts is not None:
|
||||
self.last_ts = ts
|
||||
|
||||
|
||||
def fake_news(asset: str, rng: random.Random = random) -> Verdict:
|
||||
kind = rng.choices(["bullish", "neutral", "bearish"], [0.40, 0.35, 0.25])[0]
|
||||
conf = round(rng.uniform(0.35, 0.9), 2)
|
||||
text = {"bullish": "Simulated positive headlines.", "neutral": "Simulated mixed headlines.",
|
||||
"bearish": "Simulated negative headlines."}[kind]
|
||||
return Verdict(kind, conf, f"{text} (demo, not real news about {asset})", [])
|
||||
|
||||
|
||||
class Simulator:
|
||||
"""Runs the strategy on every instrument, on real (Yahoo) or simulated candles.
|
||||
|
||||
process(symbol, action, price_eur, reason) is the bot's normal decision path.
|
||||
Prices passed to it are in euros, so the fake account is one clean euro balance:
|
||||
US-dollar assets are converted with the live EUR/USD rate.
|
||||
"""
|
||||
|
||||
def __init__(self, process, mark, mode: str = "real", interval: str = "1h",
|
||||
poll_seconds: float = 300, tick_seconds: float = 5, seed: int | None = None,
|
||||
fetch=None, fx=None, fallback_rates: dict | None = None,
|
||||
on_price=None, on_equity=None, pause: float = 0.0):
|
||||
from . import marketdata
|
||||
self._md = marketdata
|
||||
self.process, self.mark, self.mode, self.interval = process, mark, mode, interval
|
||||
self.pause = pause # seconds between Yahoo requests
|
||||
self.on_price, self.on_equity = on_price, on_equity # optional history recorders
|
||||
self.wait = poll_seconds if mode == "real" else tick_seconds
|
||||
self.fetch = fetch or (lambda sym: marketdata.fetch(sym, interval))
|
||||
self.fx_fn = fx or marketdata.fx_rates
|
||||
# Units of foreign currency per 1 euro. Live rates replace these when they load.
|
||||
self.rates = dict(fallback_rates or {"USD": 1.10, "GBP": 0.87})
|
||||
self.fx_checked = 0.0
|
||||
self.rng = random.Random(seed)
|
||||
self.series = {
|
||||
sym: Series(sym, 0.012 if inst.asset_class == "crypto" else 0.006,
|
||||
START.get(sym, 100.0) * self.rng.uniform(0.97, 1.03),
|
||||
currency=inst.currency)
|
||||
for sym, inst in INSTRUMENTS.items()
|
||||
}
|
||||
self.equity_history: deque = deque(maxlen=720)
|
||||
self.candles = 0
|
||||
self.last_poll = 0.0
|
||||
self._stop = threading.Event()
|
||||
if mode == "simulated":
|
||||
for _ in range(SLOW + 40): # warm up indicators without trading
|
||||
for s in self.series.values():
|
||||
s.step(self.rng)
|
||||
|
||||
def to_eur(self, s: Series, price: float) -> float:
|
||||
return self._md.to_eur(price, s.currency, self.rates)
|
||||
|
||||
def sync_positions(self, held: set[str]):
|
||||
for s in self.series.values():
|
||||
s.in_position = INSTRUMENTS[s.symbol].broker_symbol in held
|
||||
if not s.in_position:
|
||||
s.trail = None
|
||||
|
||||
def _record(self, s: Series, ts: float):
|
||||
"""Remember the candle's price in euros, for the scorecard."""
|
||||
if not self.on_price:
|
||||
return
|
||||
try:
|
||||
self.on_price(s.symbol, ts, round(self.to_eur(s, s.price), 6))
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def _evaluate(self, s: Series, at: float | None = None):
|
||||
sig = signal(s)
|
||||
if not sig:
|
||||
return
|
||||
action, reason = sig
|
||||
# Real data: judge "is the exchange open?" at the candle's own time, not now, because
|
||||
# the last candle of a session is only confirmed after the exchange has closed.
|
||||
# Simulated data runs around the clock, so the hours check is skipped there.
|
||||
try:
|
||||
price_eur = round(self.to_eur(s, s.price), 4)
|
||||
except ValueError as e:
|
||||
s.error = str(e)
|
||||
return
|
||||
r = self.process(s.symbol, action, price_eur, reason,
|
||||
at=at, enforce_hours=self.mode == "real")
|
||||
if r.get("decision") == "executed":
|
||||
s.in_position = action == "buy"
|
||||
if action == "sell":
|
||||
s.trail = None
|
||||
|
||||
def _update_real(self, s: Series):
|
||||
inst = INSTRUMENTS[s.symbol]
|
||||
try:
|
||||
candles, currency = self.fetch(inst.yahoo or s.symbol)
|
||||
s.error = ""
|
||||
except Exception as e:
|
||||
s.error = f"price feed: {e}"[:160]
|
||||
return
|
||||
if currency:
|
||||
s.currency = currency
|
||||
new = [c for c in candles if c.ts > s.last_ts]
|
||||
if not new:
|
||||
return
|
||||
first_load = s.last_ts == 0
|
||||
for c in new:
|
||||
s.append(c.high, c.low, c.close, c.volume, c.ts)
|
||||
self._record(s, c.ts)
|
||||
if not first_load: # history only warms up the indicators
|
||||
self._evaluate(s, at=c.ts)
|
||||
try:
|
||||
self.mark(inst.broker_symbol, self.to_eur(s, s.price))
|
||||
except ValueError as e:
|
||||
s.error = str(e)
|
||||
|
||||
def run_once(self, equity_fn=None, held_fn=None):
|
||||
if held_fn:
|
||||
self.sync_positions(held_fn())
|
||||
if self.mode == "real" and time.time() - self.fx_checked > 1800:
|
||||
self.rates.update(self.fx_fn() or {}) # keep the old rate for any that fail
|
||||
self.fx_checked = time.time()
|
||||
for s in self.series.values():
|
||||
if self.mode == "real":
|
||||
self._update_real(s)
|
||||
if self.pause:
|
||||
time.sleep(self.pause)
|
||||
else:
|
||||
s.step(self.rng)
|
||||
self.mark(INSTRUMENTS[s.symbol].broker_symbol, self.to_eur(s, s.price))
|
||||
self._record(s, time.time())
|
||||
self._evaluate(s)
|
||||
self.candles += 1
|
||||
self.last_poll = time.time()
|
||||
if equity_fn:
|
||||
eq = round(equity_fn(), 2)
|
||||
self.equity_history.append((time.time(), eq))
|
||||
if self.on_equity:
|
||||
self.on_equity(time.time(), eq)
|
||||
|
||||
def prices(self) -> list[dict]:
|
||||
out = []
|
||||
for s in self.series.values():
|
||||
c = list(s.closes)
|
||||
row = {"symbol": s.symbol, "exchange": INSTRUMENTS[s.symbol].exchange,
|
||||
"currency": s.currency, "error": s.error,
|
||||
"last_candle": s.last_ts or None}
|
||||
if c:
|
||||
chg = (c[-1] / c[-21] - 1) * 100 if len(c) > 21 else 0.0
|
||||
f, sl = ema(c, FAST)[-1], ema(c, SLOW)[-1]
|
||||
row.update(price=round(s.price, 4), change_20=round(chg, 2),
|
||||
trend="up" if f > sl else "down", in_position=s.in_position,
|
||||
spark=[round(x, 4) for x in c[-60:]])
|
||||
out.append(row)
|
||||
return out
|
||||
|
||||
INTERVAL_SECONDS = {"15m": 900, "1h": 3600, "1d": 86400}
|
||||
|
||||
def health(self) -> dict:
|
||||
"""Per-market checks for the dashboard: is the feed alive, and why is there no buy yet."""
|
||||
from . import exchanges
|
||||
now = time.time()
|
||||
lag = self.INTERVAL_SECONDS.get(self.interval, 3600) * 3
|
||||
rows = []
|
||||
for s in self.series.values():
|
||||
inst = INSTRUMENTS[s.symbol]
|
||||
d = diagnose(s)
|
||||
feed, note = "ok", ""
|
||||
if s.error:
|
||||
feed, note = "error", s.error
|
||||
elif not s.closes:
|
||||
feed, note = "waiting", "no data yet"
|
||||
elif (self.mode == "real" and self.interval != "1d" and s.last_ts
|
||||
and now - s.last_ts > lag and exchanges.is_open(exchanges.EXCHANGES[inst.exchange])):
|
||||
feed, note = "stale", "exchange is open but no new candle for a while"
|
||||
if d.get("no_volume") and feed == "ok":
|
||||
note = "no volume data from the price source: this market cannot trigger a buy"
|
||||
if s.in_position:
|
||||
status = "holding"
|
||||
elif d["ready"]:
|
||||
status = "buy_signal"
|
||||
elif d.get("warming"):
|
||||
status = "warming"
|
||||
else:
|
||||
status = "waiting"
|
||||
rows.append({"symbol": s.symbol, "exchange": inst.exchange, "feed": feed, "note": note,
|
||||
"last_candle": s.last_ts or None, "candles": len(s.closes),
|
||||
"status": status, "trend_up": d.get("trend_up", False),
|
||||
"checks": d["checks"], "missing": d["missing"],
|
||||
"warming": d.get("warming", False), "have": d.get("have"), "need": d.get("need")})
|
||||
live = [r for r in rows if not r["warming"] and r["feed"] != "error"]
|
||||
closest = sorted((r for r in live if r["status"] == "waiting"), key=lambda r: len(r["missing"]))[:3]
|
||||
return {
|
||||
"markets": rows,
|
||||
"feed_ok": sum(r["feed"] == "ok" for r in rows), "total": len(rows),
|
||||
"uptrend": sum(r["trend_up"] for r in rows),
|
||||
"last_check": self.last_poll or None,
|
||||
"next_check": (self.last_poll + self.wait) if self.last_poll else None,
|
||||
"every_seconds": self.wait, "updates": self.candles,
|
||||
"closest": [{"symbol": r["symbol"], "missing": r["missing"]} for r in closest],
|
||||
"buy_ready": [r["symbol"] for r in rows if r["status"] == "buy_signal"],
|
||||
}
|
||||
|
||||
def loop(self, equity_fn, held_fn):
|
||||
while not self._stop.is_set():
|
||||
try:
|
||||
self.run_once(equity_fn, held_fn)
|
||||
except Exception as e: # keep the demo alive; order errors are logged by process()
|
||||
print("demo update failed:", e)
|
||||
self._stop.wait(self.wait)
|
||||
|
||||
def start(self, equity_fn, held_fn):
|
||||
threading.Thread(target=self.loop, args=(equity_fn, held_fn), daemon=True).start()
|
||||
|
||||
def stop(self):
|
||||
self._stop.set()
|
||||
Reference in New Issue
Block a user