src.bot

🦉 AthenaAI is an AI-powered ensemble machine-learning trading bot for PocketOption, built on BinaryOptionsToolsV2 → Get it on GitLab
💬 Need help? Join the Chipa Discord · ⚡ Go no-code with ChipaEditor

Source: src/bot.py. AITradingBot is the orchestrator: it wires every other component together, connects to PocketOption via BinaryOptionsToolsV2.pocketoption.PocketOptionAsync, and runs three concurrent asyncio loops — candle streaming, trade decisions, and result checking. If BinaryOptionsToolsV2 is not installed, the module prints ERROR: BinaryOptionsToolsV2 not installed. and calls sys.exit(1) at import time.

Lifecycle overview

AITradingBot(cfg)                       # construct components
  └─ await start()
       ├─ banner logging
       ├─ PO_RETRAIN=1 ? delete brain : _load_brain()
       ├─ if no brain: _reload_from_journal() → _load_dataset(cfg.dataset_path)
       ├─ connect PocketOptionAsync(ssid), sleep 3s, log balance
       ├─ fetch warmup candles (get_candles)
       └─ asyncio.gather(
            _candle_stream(),     # loop 1: keep self.candles fresh
            _trade_loop(),        # loop 2: gates → predict → place trades
            _result_checker(),    # loop 3: resolve trades → learn
          )
await stop()                            # _running=False, _save_brain(), final stats log

The three loops share state through self.candles, self.pending_trades, and the component objects; because they run on one event loop there is no locking.

`init(self, cfg: BotConfig)`

Parameter	Type	Meaning
`cfg`	`BotConfig`	All settings

Creates: candles — deque(maxlen=cfg.lookback) of Candle; EnsemblePredictor; FeatureEngine; FeatureLab (review_interval=50); RegimeDetector; MoneyManager; TradeJournal (cfg.db_path — opens/creates the SQLite file immediately); PerformanceTracker; AdaptiveStrategy (review_interval=25, min_samples=15); ExpirySelector (cfg.expiry_options). Plus internals: pending_trades: dict[str, TradeRecord], _cooldown_until, _samples_since_fit, _running, _signal_history: list[(candle_ts, Direction, confidence)], _last_trade_time.

`async start(self)`

Main entry point (blocking until the loops die).

Banner — logs version/asset/expiry options/model list/confidence band/hours/feature counts.
Brain load — reads PO_RETRAIN directly from the environment (not from BotConfig). If "1", logs 🔄 Force retrain requested — ignoring saved brain. and deletes cfg.brain_path if it exists. Otherwise calls _load_brain().
If the brain loaded, dataset training is skipped. Otherwise: _reload_from_journal() then, if cfg.dataset_path is set, _load_dataset(). Both are wrapped in try/except that logs and continues.
Connect — PocketOptionAsync(ssid=cfg.ssid), await asyncio.sleep(3) for the websocket handshake, then logs Connected! Balance: $X.XX. An invalid SSID typically surfaces here as an exception from the client.
Warmup candles — enforces effective_warmup = max(cfg.warmup_candles, 60) (features need ≥ 50 candles for SMA50; a warning is logged if the config was lower). Calls client.get_candles(asset, timeframe, effective_warmup * timeframe) — the third argument is seconds of history, not a candle count. Each raw candle goes through _parse_candle into the deque.
Sets _running = True and await asyncio.gather(...) on the three loops. start() returns only when all three finish (normally after a fatal stream error or stop()).

Loop 1 — `async _candle_stream(self)`

Keeps self.candles current. Prefers client.subscribe_symbol_time_aligned(asset, timedelta(seconds=timeframe)), which delivers completed candles on interval boundaries — a v6 fix so features are computed on closed candles rather than noisy in-progress ticks. Falls back to subscribe_symbol(asset, timedelta(...)); if neither method exists, logs an error and sets _running = False (killing the other loops on their next check).

For each streamed candle: parse with _parse_candle; append if its timestamp is newer than the last candle; if the timestamp equals the last one, replace the last candle (same candle updating). Any exception logs Candle stream error: <e> and stops the bot (_running = False) — there is no automatic reconnect.

Loop 2 — `async _trade_loop(self)`

The decision loop. Sleeps 2 s at start, then iterates every cfg.poll_interval seconds (default 2.0). A diagnostic “why am I not trading” line (⏸ <reason>) is logged at most every 30 s. Gates run in this exact order; any failure continues:

Warmup: len(candles) < max(warmup_candles, 60).
Max concurrent trades: len(pending_trades) >= max_concurrent_trades.
Wait between trades: now − _last_trade_time < min_wait_between_trades.
Daily loss limit: money_mgr.can_trade() is False.
Cooldown: now < _cooldown_until.
Trading hours: current UTC hour not in cfg.trading_hours (skipped if the tuple is empty).
Adaptive extra cooldown: adaptive.get_extra_cooldown() seconds since the last trade.
Features: features_engine.compute(candles, feature_window); None → skip. Result is passed through np.nan_to_num.
Regime: regime_detector.detect(candles, regime_window); skip if VOLATILE and skip_volatile_regime.
Prediction: ensemble.predict(features) → (direction, confidence).
Confidence floor: confidence < min_confidence → skip and clear _signal_history.
Confidence cap (v6): confidence > max_confidence → skip as likely-overfit noise, clear _signal_history.
Low-range candle (v6): last candle’s high − low < 0.00005 (~0.5 pips on EURUSD, hard-coded) → skip.
Indicator alignment (if require_indicator_alignment): _check_indicator_alignment() must pass.
Signal confirmation: _check_signal_ready() must pass (see below); on pass, _signal_history is cleared.
Consecutive-loss cooldown: if perf.consec_losses >= max_consec_losses, set _cooldown_until = now + cooldown_seconds, log a warning, reset the streak, skip.
Multi-timeframe confirmation (v6): with ≥ 100 candles, samples every 5th candle to a pseudo-5-minute series; computes SMA5 and SMA20 of the sampled closes; a CALL against a 5-min downtrend (or PUT against an uptrend) is skipped.
Adaptive gate: adaptive.should_trade(direction, regime, confidence, utc_hour, min_confidence); refusal logs 🧠 Adaptive skip: <reason>.

If everything passes: stake = money_mgr.compute_stake(confidence, perf.win_rate, payout=0.85); chosen_expiry = expiry_selector.select(regime, features, confidence); log the ▶ TRADE … line; call client.buy(asset, stake, expiry) for CALL or client.sell(...) for PUT (each returns (trade_id, _)).

Side effects after placement: builds a TradeRecord, stores it in pending_trades, journal.save_trade(record) (DB write — features not yet attached, so the pending row has features = NULL), updates _last_trade_time, then attaches record._features (ndarray), record._direction_int (1=CALL/0=PUT), and record.features_json.

Any exception in an iteration is logged (Trade loop error: …, with traceback) followed by a 5 s sleep — the loop itself survives.

Loop 3 — `async _result_checker(self)`

Every 3 s, scans pending_trades:

Skips a trade until elapsed >= rec.expiry + 2 seconds.
Calls await client.check_win(tid). The result may be a dict (reads result or status) or a string; if the parsed value isn’t win/loss/draw, it substring-searches the raw text for "win", "loss"/"lose", "draw" — otherwise leaves the trade pending for the next pass.
Computes profit with hard-coded payout 0.85: win → +stake*0.85, loss → −stake, draw → 0.0. Updates the record (result, profit, exit_time).
Side effects per resolved trade: perf.record(), money_mgr.record(), journal.save_trade(rec) (row overwrite, now with features), adaptive.record_trade(...) (with the entry hour in UTC), expiry_selector.record_result(...), and a ✅/❌/➖ result log line with perf.summary() and the expiry stats.
Online learning (win/loss only, and only if _features is attached): label = _direction_int on a win, 1 − _direction_int on a loss; ensemble.add_sample(); every cfg.retrain_every samples → ensemble.partial_fit(). Additionally (v6), when len(ensemble._batch_X) >= 200 and divisible by 100, the batch buffers are trimmed to the last 500 samples and train_batch_models() re-runs, logging 🔄 Batch models retrained on recent N samples — this keeps GBM/RF from going stale.
Every 10 resolved trades (perf.total % 10 == 0): journal.save_snapshot(...) and _save_brain() (auto-persistence).
Errors from check_win are logged at DEBUG and retried; a trade older than expiry * 5 seconds is abandoned with a warning and removed.

Private helpers

`_load_dataset(self, path: str)`

Pre-trains the ensemble from a historical CSV before going live (used only when no saved brain exists). Parses either HistData semicolon format (no headers, YYYYMMDD HHMMSS;O;H;L;C[;V]) or headered CSV (comma or semicolon; time column time/timestamp/date/Date, either YYYY-MM-DD HH:MM:SS or a numeric epoch; OHLC with lower/uppercase names; volume from tick_volume/volume/Volume/real_volume). Malformed rows are silently skipped.

Then: requires ≥ 50 candles (else warns and returns); caps at the most recent 500,000; label horizon = max(1, default_expiry / timeframe) candles; for each index builds features from the trailing lookback candles and labels 1 if the close label_horizon candles ahead is higher, 0 if lower, skipping flat closes. Requires ≥ 20 samples. Splits 70/30 chronologically: feeds the 70% to the ensemble in 5,000-sample chunks (partial_fit per chunk), trains the batch models, then walk-forward tests on the 30% (if > 100 samples) while continuing online learning during the test, logging the honest win rate against a breakeven computed from a 92% payout (1/(1+0.92) ≈ 52.1%). Finally logs the sample counts and calls _save_brain(). This near-duplicates src.training.dataset/trainer — prefer train.py for serious training (it is parallelized and supports the GPU MLP).

`_reload_from_journal(self)`

Loads completed trades via journal.load_completed_trades(). For each: decodes features_json; skips vectors whose length differs from the first (most-recent-schema) trade’s length; label = direction int if the trade won, inverted if it lost; ensemble.add_sample(). Also feeds FeatureLab when the vector length equals the current 57-dim schema. Then partial_fit(), restores perf.wins/perf.losses, and replays trades into adaptive.record_trade(...). Note: the journal query only returns direction/result/features, so the adaptive replay’s regime/confidence/hour always fall back to "ranging"/0.6/12 (see journal.md). Corrupted entries are skipped silently.

`_check_indicator_alignment(self, features, direction) -> bool`

2-of-3 vote using features[14] (as RSI), features[12] (MACD histogram), features[10] (SMA cross). For CALL the votes are RSI < 70, MACD hist > 0, SMA cross > 0; for PUT: RSI > 30, MACD hist < 0, SMA cross < 0. Returns True when ≥ 2 agree; logs a DEBUG line otherwise. (Index 14 is actually the rsi_zone flag in the current feature layout — raw RSI is index 13; the code is documented as-is.)

`_check_signal_ready(self, direction, confidence, candle_ts) -> bool`

Requires cfg.signal_confirmations consecutive candles to agree on direction. Records at most one signal per unique candle timestamp (a repeat timestamp returns False immediately). History is trimmed to signal_confirmations * 3 entries. Passes when the last N recorded signals all match the current direction; logs ✅ Signal CONFIRMED: … with the average confidence. With the default signal_confirmations = 1 it passes on the first new candle.

`_save_brain(self)` / `_load_brain(self) -> bool`

_save_brain: ensemble.save_brain(cfg.brain_path) plus a pickle of expiry_selector.save_state() to brain_path with .pkl → _expiry.pkl (e.g. athena_brain_expiry.pkl). All failures caught and logged as warnings. _load_brain: ensemble.load_brain(), then loads the expiry pickle if present; returns whether the main brain loaded.

`_parse_candle(raw) -> Candle` (static)

Tolerant parser for the PocketOption feed: dict (keys time/timestamp, open, high, low, close, volume), list/tuple (positional [ts, o, h, l, c, (v)]), or attribute-style object. Missing fields default to 0.

`async stop(self)`

Sets _running = False (the loops exit on their next iteration), saves the brain and expiry state, and logs Bot stopped. Final stats: <perf.summary()>. Called by main.py on Ctrl+C. It does not close the websocket client or the SQLite connection explicitly.

Usage

import asyncio
from src.config import BotConfig
from src.bot import AITradingBot

bot = AITradingBot(BotConfig(ssid="your-session-id"))
try:
    asyncio.run(bot.start())
except KeyboardInterrupt:
    asyncio.run(bot.stop())

Risk note

This class places real trades. Test with a demo-account SSID and conservative stakes first — binary options trading can lose money, and past performance does not guarantee future results.

src.bot

Lifecycle overview

__init__(self, cfg: BotConfig)

async start(self)

Loop 1 — async _candle_stream(self)

Loop 2 — async _trade_loop(self)

Loop 3 — async _result_checker(self)

Private helpers

_load_dataset(self, path: str)

_reload_from_journal(self)

_check_indicator_alignment(self, features, direction) -> bool

_check_signal_ready(self, direction, confidence, candle_ts) -> bool

_save_brain(self) / _load_brain(self) -> bool

_parse_candle(raw) -> Candle (static)

async stop(self)