Compare commits
25 Commits
main
...
4db6121ca7
| Author | SHA1 | Date | |
|---|---|---|---|
 harwinder
|
4db6121ca7 | ||
|
harwinder
|
5e12307b1f | ||
|
harwinder
|
4be7077c0a | ||
|
harwinder
|
736e33302b | ||
|
harwinder
|
a7bed99caa | ||
|
harwinder
|
dc9c76a716 | ||
|
harwinder
|
a15dc40050 | ||
|
harwinder
|
b3e0da7455 | ||
|
Harwinder
|
037dec643e | ||
|
Harwinder
|
3a09dfd62f | ||
|
Harwinder
|
353ff05267 | ||
|
Harwinder
|
a596e7cab2 | ||
|
Harwinder
|
c72e8e669b | ||
|
Harwinder
|
3d9f4dc201 | ||
|
Harwinder
|
e30535f5e9 | ||
|
Harwinder
|
a687db9413 | ||
|
Harwinder
|
b7d03a9b61 | ||
|
Harwinder
|
b38ed17c96 | ||
|
Harwinder
|
dcd98fffa2 | ||
|
Harwinder
|
70990532a3 | ||
|
Harwinder
|
53e6e07829 | ||
|
Harwinder
|
7699e6dd1d | ||
|
Harwinder
|
636f0304ae | ||
|
Harwinder
|
6ebdc34cd3 | ||
|
Harwinder
|
bc1844b233 |
+25
@@ -0,0 +1,25 @@
|
||||
# Secrets
|
||||
.env
|
||||
.env.local
|
||||
|
||||
# Editor / tooling
|
||||
.claude/
|
||||
.vscode/
|
||||
.idea/
|
||||
|
||||
# Python
|
||||
__pycache__/
|
||||
*.pyc
|
||||
*.egg-info/
|
||||
.venv/
|
||||
venv/
|
||||
|
||||
# OS
|
||||
.DS_Store
|
||||
Thumbs.db
|
||||
|
||||
# Logs
|
||||
*.log
|
||||
|
||||
# Backtesting (scripts, data, results)
|
||||
backtest/
|
||||
@@ -0,0 +1,198 @@
|
||||
# ForexBot2 — USD/JPY Signal Intelligence
|
||||
|
||||
A focused USD/JPY signal generator + walk-forward backtester. Live signals
|
||||
and backtests run through the **same** technical engine, so what you measure
|
||||
in a backtest is exactly what you'd execute live.
|
||||
|
||||
## Setup
|
||||
|
||||
```bash
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
API key (optional — a default key is in `config.py`):
|
||||
|
||||
```bash
|
||||
export TWELVE_DATA_API_KEY=your_key_here # Linux/Mac
|
||||
$env:TWELVE_DATA_API_KEY="your_key_here" # PowerShell
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Live Signal
|
||||
|
||||
```bash
|
||||
python main.py # H1, summary view
|
||||
python main.py --detail # Full indicator breakdown
|
||||
python main.py --timeframe H4 --detail # H4 instead of H1
|
||||
python main.py --json # JSON output (for piping)
|
||||
```
|
||||
|
||||
| Option | Default | Description |
|
||||
|---------------|---------|--------------------------------------------|
|
||||
| `--timeframe` | `H1` | `M5 M15 M30 H1 H4 D1` |
|
||||
| `--detail` | off | Indicator breakdown, key levels, reasons |
|
||||
| `--json` | off | Machine-readable output |
|
||||
| `--verbose` | off | Debug logging |
|
||||
|
||||
### Output
|
||||
|
||||
```
|
||||
USD/JPY │ Price: 149.230 │ Regime: trending_up │ Vol: normal
|
||||
|
||||
SIGNAL: BUY │ Score: +28.4 │ Grade: B │ Confidence: 62%
|
||||
Action: BUY — Decent setup, wait for confirmation
|
||||
|
||||
Multi-Timeframe: ✓ ALIGNED
|
||||
M15: BUY (+18.2)
|
||||
H1: BUY (+28.4)
|
||||
H4: STRONG BUY (+45.1)
|
||||
|
||||
Trade Setup:
|
||||
Direction: BUY
|
||||
Entry: 149.230
|
||||
Stop Loss: 148.960 (27.0 pips)
|
||||
Take Profit 1: 149.770 (54.0 pips)
|
||||
Take Profit 2: 150.040
|
||||
Risk:Reward: 1:2.0
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Backtest (Walk-Forward)
|
||||
|
||||
The backtester replays USD/JPY history bar-by-bar through the live signal
|
||||
pipeline. No lookahead, no parallel implementation — what passes in
|
||||
backtest passes live.
|
||||
|
||||
```bash
|
||||
python main.py --backtest # Full available history
|
||||
python main.py --backtest --bars 2000 # Last 2000 H1 bars
|
||||
python main.py --backtest --start 2024-01-01 --end 2024-12-31
|
||||
python main.py --backtest --timeframe H4 # Backtest on H4
|
||||
python main.py --backtest --min-grade A # Only A/A+ entries
|
||||
python main.py --backtest --journal # Last 10 trades printed
|
||||
python main.py --backtest --journal-csv trades.csv # Full journal to CSV
|
||||
python main.py --backtest --regime-filter # Skip choppy/ranging bars
|
||||
python main.py --backtest --regime-filter --regime-min-adx 35
|
||||
python main.py --backtest --session-filter # Trade only 07-16 UTC
|
||||
python main.py --backtest --session-filter --session-start 8 --session-end 17
|
||||
python main.py --backtest --auto-session-filter # Reactive session toggle
|
||||
python main.py --backtest --auto-session-filter --auto-session-lookback 15 \
|
||||
--auto-session-threshold-pct -0.5
|
||||
```
|
||||
|
||||
### Regime filter
|
||||
|
||||
The engine is a confluence-based trend-follower — it makes money in trending
|
||||
regimes and loses in chop. `--regime-filter` gates entries on H4 ADX:
|
||||
signals only fire when ADX ≥ `--regime-min-adx` (default 30). Sweet spot is
|
||||
ADX 30–35; tighter cuts trades faster than it improves quality.
|
||||
|
||||
### Session filter
|
||||
|
||||
`--session-filter` restricts entries to a UTC hour window (default 07-16,
|
||||
covering London + NY). Diagnostic on 2025-11 → 2026-05 showed 47% WR /
|
||||
+127 pips inside that window vs 0% WR / -571 pips outside it. Override
|
||||
bounds with `--session-start` (inclusive) and `--session-end` (exclusive).
|
||||
|
||||
Tradeoff: it's regime-specific medicine. In trending regimes (e.g. 2024)
|
||||
it cuts winning off-hours trades and gives back ~33% of the edge. Ships
|
||||
**default off** because the pure regime filter still wins cumulative
|
||||
across the 2024 / 2023 / 2026 windows.
|
||||
|
||||
### Auto session toggle
|
||||
|
||||
`--auto-session-filter` is a reactive variant: it tracks the rolling mean
|
||||
`pnl_pct` over the last N closed trades (`--auto-session-lookback`,
|
||||
default 10) and activates the 07-16 UTC window only when that mean drops
|
||||
below `--auto-session-threshold-pct` (default `-0.3`). Releases
|
||||
automatically once expectancy recovers.
|
||||
|
||||
Less aggressive than the manual flag — preserves more trend edge but
|
||||
reacts slowly because the deque must fill with losses before kicking in.
|
||||
Use this when you don't want to manually toggle the regime medicine.
|
||||
|
||||
### Execution model
|
||||
|
||||
| Aspect | Behavior |
|
||||
|--------------------|-------------------------------------------------------------------|
|
||||
| Entry | Next bar's open (no current-bar lookahead) |
|
||||
| Stop Loss | 1.5 × ATR from entry (configurable) |
|
||||
| Take Profit | RR × stop distance (default 1:2) |
|
||||
| Same-bar SL & TP | Conservative: SL fills first |
|
||||
| Spread cost | Half-spread on entry + half-spread on exit (full round-trip) |
|
||||
| Slippage | 0.5 pips per fill (entry + exit) |
|
||||
| Position size | 1% of current equity risked per trade |
|
||||
| Concurrency | One open position at a time |
|
||||
| News in backtest | Disabled — RSS/calendar can't be replayed without lookahead |
|
||||
|
||||
### Output
|
||||
|
||||
```
|
||||
Backtest Summary — USD/JPY
|
||||
─────────────────────────────────────────────────
|
||||
Trades: 87 (52W / 35L)
|
||||
Win Rate: 59.8%
|
||||
Profit Factor: 1.84
|
||||
Expectancy: +12.4 pips/trade (+12.42 per trade)
|
||||
Initial Balance: $10,000.00
|
||||
Final Balance: $11,084.00
|
||||
Total Return: +10.84%
|
||||
CAGR: +18.92%
|
||||
Max Drawdown: -4.21%
|
||||
Sharpe Ratio: 1.42
|
||||
Sortino Ratio: 2.18
|
||||
Avg Duration: 14.3 bars
|
||||
Win Streak: 7 | Loss Streak: 4
|
||||
─────────────────────────────────────────────────
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Parameter Optimization (parallel)
|
||||
|
||||
```bash
|
||||
python main.py --backtest --optimize
|
||||
```
|
||||
|
||||
Runs a 3×3×3 grid (27 combos) over `atr_sl_multiplier`, `default_rr_ratio`,
|
||||
and `min_score` (signal-score threshold). Combos run in parallel across all
|
||||
CPU cores via `multiprocessing.Pool`. Twelve Data is hit once — workers
|
||||
share an on-disk parquet cache (`.cache/usdjpy_<tf>.parquet`).
|
||||
|
||||
Output ranks combos by total return:
|
||||
|
||||
```
|
||||
Top 10 Parameter Combinations (by total return):
|
||||
|
||||
# Return% PF WinR Trades MaxDD% Sharpe Params
|
||||
──────────────────────────────────────────────────────────────────────
|
||||
1 +14.21% 2.10 62.5% 64 -3.84 1.78 atr_sl_multiplier=1.5, default_rr_ratio=2.5, min_score=25.0
|
||||
2 +11.93% 1.92 58.7% 71 -4.11 1.55 atr_sl_multiplier=1.0, default_rr_ratio=2.0, min_score=15.0
|
||||
...
|
||||
```
|
||||
|
||||
Customize the grid in `config.py → BacktestConfig.param_grid`.
|
||||
|
||||
---
|
||||
|
||||
## Files
|
||||
|
||||
| File | Role |
|
||||
|-----------------------|---------------------------------------------------|
|
||||
| `main.py` | CLI entry point (live + backtest + optimize) |
|
||||
| `config.py` | All parameters in one place |
|
||||
| `data_provider.py` | Twelve Data fetcher + parquet cache |
|
||||
| `engine.py` | Technical indicators (8 + divergence + patterns) |
|
||||
| `signal_aggregator.py`| Multi-TF aggregation, grading, trade setup |
|
||||
| `news_engine.py` | RSS sentiment + economic calendar (live only) |
|
||||
| `backtest.py` | Walk-forward replay + parallel optimizer |
|
||||
| `metrics.py` | Win rate, PF, Sharpe, max DD, trade journal |
|
||||
|
||||
---
|
||||
|
||||
## Disclaimer
|
||||
|
||||
For educational and research use. Past performance does not guarantee
|
||||
future results. Always use proper risk management.
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,8 +1,6 @@
|
||||
"""
|
||||
Forex Signal Intelligence Platform - Configuration
|
||||
===================================================
|
||||
Central configuration for all signal analysis parameters.
|
||||
Tuned by market regime and validated against historical performance.
|
||||
ForexBot2 — Configuration
|
||||
==========================================
|
||||
"""
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
@@ -37,160 +35,146 @@ class MarketSession(Enum):
|
||||
OVERLAP_LONDON_NY = "london_ny_overlap"
|
||||
|
||||
|
||||
# ── Major Forex Pairs ──────────────────────────────────────────────
|
||||
MAJOR_PAIRS = [
|
||||
"EURUSD=X", "GBPUSD=X", "USDJPY=X", "USDCHF=X",
|
||||
"AUDUSD=X", "USDCAD=X", "NZDUSD=X",
|
||||
]
|
||||
# ── Supported pairs ──────────────────────────────────────────────
|
||||
USDJPY = "USDJPY=X"
|
||||
EURUSD = "EURUSD=X"
|
||||
GBPUSD = "GBPUSD=X"
|
||||
XAUUSD = "XAU/USD"
|
||||
|
||||
CROSS_PAIRS = [
|
||||
"EURGBP=X", "EURJPY=X", "GBPJPY=X", "AUDJPY=X",
|
||||
"EURCHF=X", "CADJPY=X",
|
||||
]
|
||||
|
||||
# Yahoo Finance symbol mapping for display
|
||||
SYMBOL_DISPLAY = {
|
||||
"EURUSD=X": "EUR/USD", "GBPUSD=X": "GBP/USD",
|
||||
"USDJPY=X": "USD/JPY", "USDCHF=X": "USD/CHF",
|
||||
"AUDUSD=X": "AUD/USD", "USDCAD=X": "USD/CAD",
|
||||
"NZDUSD=X": "NZD/USD", "EURGBP=X": "EUR/GBP",
|
||||
"EURJPY=X": "EUR/JPY", "GBPJPY=X": "GBP/JPY",
|
||||
"AUDJPY=X": "AUD/JPY", "EURCHF=X": "EUR/CHF",
|
||||
"CADJPY=X": "CAD/JPY",
|
||||
PAIR_INFO = {
|
||||
USDJPY: {"display": "USD/JPY", "pip_value": 0.01, "is_jpy_pair": True},
|
||||
EURUSD: {"display": "EUR/USD", "pip_value": 0.0001, "is_jpy_pair": False},
|
||||
GBPUSD: {"display": "GBP/USD", "pip_value": 0.0001, "is_jpy_pair": False},
|
||||
XAUUSD: {"display": "XAU/USD", "pip_value": 0.10, "is_jpy_pair": False},
|
||||
}
|
||||
|
||||
# Defaults (kept for backward compat)
|
||||
DISPLAY = "USD/JPY"
|
||||
PIP_VALUE = 0.01
|
||||
|
||||
|
||||
@dataclass
|
||||
class TechnicalConfig:
|
||||
"""Technical indicator parameters - carefully tuned for Forex."""
|
||||
# EMA periods (fast/medium/slow for trend detection)
|
||||
"""Technical indicator parameters."""
|
||||
ema_fast: int = 9
|
||||
ema_medium: int = 21
|
||||
ema_slow: int = 50
|
||||
ema_trend: int = 200
|
||||
|
||||
# RSI
|
||||
rsi_period: int = 14
|
||||
rsi_overbought: float = 70.0
|
||||
rsi_oversold: float = 30.0
|
||||
rsi_neutral_upper: float = 60.0
|
||||
rsi_neutral_lower: float = 40.0
|
||||
|
||||
# MACD (12, 26, 9 is standard)
|
||||
macd_fast: int = 12
|
||||
macd_slow: int = 26
|
||||
macd_signal: int = 9
|
||||
|
||||
# Bollinger Bands
|
||||
bb_period: int = 20
|
||||
bb_std: float = 2.0
|
||||
|
||||
# ATR for volatility measurement
|
||||
atr_period: int = 14
|
||||
|
||||
# Stochastic
|
||||
stoch_k: int = 14
|
||||
stoch_d: int = 3
|
||||
stoch_overbought: float = 80.0
|
||||
stoch_oversold: float = 20.0
|
||||
|
||||
# ADX for trend strength
|
||||
adx_period: int = 14
|
||||
adx_strong_trend: float = 25.0
|
||||
adx_very_strong: float = 50.0
|
||||
|
||||
# Ichimoku
|
||||
ichimoku_tenkan: int = 9
|
||||
ichimoku_kijun: int = 26
|
||||
ichimoku_senkou_b: int = 52
|
||||
|
||||
# Volume profile
|
||||
volume_ma_period: int = 20
|
||||
|
||||
# Pivot points lookback
|
||||
pivot_lookback: int = 1
|
||||
|
||||
# Divergence detection — how many bars back to scan for swing points
|
||||
divergence_lookback: int = 14
|
||||
swing_sr_lookback: int = 50
|
||||
|
||||
disabled_indicators: List[str] = field(default_factory=list)
|
||||
|
||||
|
||||
@dataclass
|
||||
class SignalConfig:
|
||||
"""Signal scoring and filtering parameters."""
|
||||
# Minimum confidence to emit a signal (0-100)
|
||||
"""Signal scoring & filtering."""
|
||||
min_confidence: float = 55.0
|
||||
|
||||
# Weight allocation for composite score
|
||||
weights: Dict[str, float] = field(default_factory=lambda: {
|
||||
"trend": 0.25, # EMA alignment, ADX
|
||||
"momentum": 0.20, # RSI, Stochastic, MACD
|
||||
"volatility": 0.15, # BB position, ATR regime
|
||||
"price_action": 0.15, # Candlestick patterns, S/R
|
||||
"multi_timeframe": 0.15,# Higher TF confirmation
|
||||
"sentiment": 0.10, # News/calendar events
|
||||
"ema_trend": 1.0,
|
||||
"rsi": 1.5,
|
||||
"bollinger": 1.5,
|
||||
"candlestick": 1.5,
|
||||
"divergence": 1.0,
|
||||
})
|
||||
|
||||
# Multi-timeframe confirmation requirements
|
||||
mtf_agreement_threshold: int = 2 # out of 3 timeframes must agree
|
||||
|
||||
# Signal cooldown (prevent over-signalling same direction)
|
||||
mtf_agreement_threshold: int = 2 # of 3 timeframes
|
||||
cooldown_bars: int = 5
|
||||
|
||||
# Risk management defaults
|
||||
default_risk_pct: float = 1.0 # risk 1% per trade
|
||||
default_rr_ratio: float = 2.0 # 1:2 risk-reward minimum
|
||||
default_risk_pct: float = 1.0
|
||||
default_rr_ratio: float = 2.0
|
||||
atr_sl_multiplier: float = 1.5
|
||||
min_rr_ratio: float = 1.2
|
||||
|
||||
|
||||
@dataclass
|
||||
class NewsConfig:
|
||||
"""Economic calendar and sentiment configuration."""
|
||||
# High-impact event currencies
|
||||
tracked_currencies: List[str] = field(default_factory=lambda: [
|
||||
"USD", "EUR", "GBP", "JPY", "CHF", "AUD", "CAD", "NZD"
|
||||
])
|
||||
|
||||
# Event impact levels to monitor
|
||||
min_impact: str = "medium" # "low", "medium", "high"
|
||||
|
||||
# Pre-event buffer (minutes before high-impact event = no new signals)
|
||||
"""Economic calendar & sentiment."""
|
||||
tracked_currencies: List[str] = field(default_factory=lambda: ["USD", "JPY", "EUR", "GBP", "XAU"])
|
||||
min_impact: str = "medium"
|
||||
pre_event_buffer_minutes: int = 30
|
||||
|
||||
# Post-event volatility window (minutes after event = cautious signals)
|
||||
post_event_buffer_minutes: int = 15
|
||||
|
||||
# News sentiment sources
|
||||
rss_feeds: List[str] = field(default_factory=lambda: [
|
||||
"https://www.forexlive.com/feed/",
|
||||
"https://www.fxstreet.com/rss",
|
||||
])
|
||||
|
||||
|
||||
@dataclass
|
||||
class FilterConfig:
|
||||
"""Regime and session filters for live signals."""
|
||||
regime_filter: bool = False
|
||||
regime_filter_timeframe: Timeframe = Timeframe.H4
|
||||
regime_filter_min_adx: float = 25.0
|
||||
|
||||
session_filter: bool = False
|
||||
session_start_hour: int = 7
|
||||
session_end_hour: int = 16
|
||||
|
||||
|
||||
@dataclass
|
||||
class PlatformConfig:
|
||||
"""Overall platform configuration."""
|
||||
"""Top-level configuration."""
|
||||
technical: TechnicalConfig = field(default_factory=TechnicalConfig)
|
||||
signals: SignalConfig = field(default_factory=SignalConfig)
|
||||
news: NewsConfig = field(default_factory=NewsConfig)
|
||||
backtest: FilterConfig = field(default_factory=FilterConfig)
|
||||
|
||||
# Default pairs to monitor
|
||||
watch_pairs: List[str] = field(default_factory=lambda: MAJOR_PAIRS)
|
||||
symbol: str = USDJPY
|
||||
display_name: str = DISPLAY
|
||||
pip_value: float = PIP_VALUE
|
||||
|
||||
# Analysis timeframes (primary + confirmation)
|
||||
primary_timeframe: Timeframe = Timeframe.H1
|
||||
confirmation_timeframes: List[Timeframe] = field(
|
||||
default_factory=lambda: [Timeframe.M15, Timeframe.H4]
|
||||
)
|
||||
|
||||
# Data source
|
||||
data_lookback_days: int = 60 # enough for 200 EMA on H1
|
||||
data_lookback_days: int = 60
|
||||
|
||||
# Twelve Data API key (overridden by TWELVE_DATA_API_KEY env var)
|
||||
twelve_data_api_key: str = "f563b22ffdfd4924955decbe1a8c8701"
|
||||
|
||||
# Dashboard refresh interval (seconds)
|
||||
refresh_interval: int = 300 # 5 minutes
|
||||
refresh_interval: int = 300
|
||||
|
||||
scan_pairs: List[str] = field(
|
||||
default_factory=lambda: [EURUSD, USDJPY, GBPUSD, XAUUSD]
|
||||
)
|
||||
scan_timeframes: List[Timeframe] = field(
|
||||
default_factory=lambda: [Timeframe.M5, Timeframe.M15, Timeframe.H1, Timeframe.H4]
|
||||
)
|
||||
candle_buffer_seconds: int = 10
|
||||
ws_cooldown_seconds: int = 300
|
||||
|
||||
# Logging
|
||||
log_level: str = "INFO"
|
||||
log_signals_to_file: bool = True
|
||||
signal_log_path: str = "signals.log"
|
||||
|
||||
Regular → Executable
+88
-360
@@ -1,23 +1,19 @@
|
||||
"""
|
||||
Forex Signal Intelligence Platform - Data Provider
|
||||
====================================================
|
||||
Retrieves and validates market data from Twelve Data API.
|
||||
Falls back to synthetic GBM data if the API is unavailable.
|
||||
ForexBot2 — Data Provider (Twelve Data SDK)
|
||||
==========================================================
|
||||
Fetches and validates OHLCV via the official `twelvedata` Python SDK.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import logging
|
||||
import os
|
||||
import time
|
||||
from collections import deque
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Dict, List, Optional
|
||||
from typing import Dict, Optional
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import requests
|
||||
from twelvedata import TDClient
|
||||
|
||||
from config import PlatformConfig, Timeframe, SYMBOL_DISPLAY
|
||||
from config import PlatformConfig, Timeframe, USDJPY, PAIR_INFO
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@@ -28,14 +24,7 @@ class DataIntegrityError(Exception):
|
||||
|
||||
|
||||
class ForexDataProvider:
|
||||
"""
|
||||
Forex data provider backed by Twelve Data API.
|
||||
|
||||
Twelve Data has native 4h candles, eliminating the H1→H4 resampling
|
||||
hack needed for Yahoo Finance. Free tier: 800 credits/day, 8 req/min.
|
||||
"""
|
||||
|
||||
TD_BASE_URL = "https://api.twelvedata.com"
|
||||
"""Twelve Data SDK client + on-disk parquet cache."""
|
||||
|
||||
TD_INTERVALS = {
|
||||
Timeframe.M1: "1min",
|
||||
@@ -48,20 +37,19 @@ class ForexDataProvider:
|
||||
Timeframe.W1: "1week",
|
||||
}
|
||||
|
||||
# Approximate bars per day for each timeframe (used to size outputsize)
|
||||
BARS_PER_DAY = {
|
||||
Timeframe.M1: 1440,
|
||||
Timeframe.M5: 288,
|
||||
Timeframe.M15: 96,
|
||||
Timeframe.M30: 48,
|
||||
Timeframe.H1: 24,
|
||||
Timeframe.H4: 6,
|
||||
Timeframe.D1: 1,
|
||||
Timeframe.W1: 0.143,
|
||||
Timeframe.M1: 1440, Timeframe.M5: 288, Timeframe.M15: 96,
|
||||
Timeframe.M30: 48, Timeframe.H1: 24, Timeframe.H4: 6,
|
||||
Timeframe.D1: 1, Timeframe.W1: 0.143,
|
||||
}
|
||||
|
||||
# Free plan: 8 API credits per minute (each symbol = 1 credit)
|
||||
RATE_LIMIT = 8
|
||||
CANDLE_SECONDS = {
|
||||
Timeframe.M1: 60, Timeframe.M5: 300, Timeframe.M15: 900,
|
||||
Timeframe.M30: 1800, Timeframe.H1: 3600, Timeframe.H4: 14400,
|
||||
Timeframe.D1: 86400, Timeframe.W1: 604800,
|
||||
}
|
||||
|
||||
RATE_LIMIT = 55
|
||||
RATE_WINDOW = 60.0
|
||||
|
||||
def __init__(self, config: PlatformConfig):
|
||||
@@ -72,94 +60,55 @@ class ForexDataProvider:
|
||||
)
|
||||
self._cache: Dict[str, pd.DataFrame] = {}
|
||||
self._cache_timestamps: Dict[str, float] = {}
|
||||
self._request_times: deque = deque() # timestamps of recent API credits used
|
||||
self._session = requests.Session()
|
||||
self._session.headers.update({
|
||||
"User-Agent": "Mozilla/5.0 (compatible; ForexIntel/1.0)"
|
||||
})
|
||||
self._request_times: deque = deque()
|
||||
self._td: Optional[TDClient] = (
|
||||
TDClient(apikey=self._api_key) if self._api_key else None
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _to_td_symbol(symbol: str) -> str:
|
||||
"""Convert internal symbol (EURUSD=X) to Twelve Data format (EUR/USD)."""
|
||||
if "/" in symbol:
|
||||
return symbol
|
||||
clean = symbol.replace("=X", "")
|
||||
return f"{clean[:3]}/{clean[3:]}"
|
||||
|
||||
# ── Public API ─────────────────────────────────────────────────
|
||||
|
||||
def fetch_ohlcv(
|
||||
self,
|
||||
symbol: str,
|
||||
timeframe: Timeframe,
|
||||
symbol: str = USDJPY,
|
||||
timeframe: Timeframe = Timeframe.H1,
|
||||
lookback_days: Optional[int] = None,
|
||||
) -> pd.DataFrame:
|
||||
"""
|
||||
Fetch OHLCV data for a Forex pair with full validation.
|
||||
|
||||
Returns a DataFrame with columns: Open, High, Low, Close, Volume
|
||||
Index is a timezone-aware DatetimeIndex in UTC.
|
||||
"""
|
||||
"""Fetch OHLCV with in-memory caching for live mode."""
|
||||
if lookback_days is None:
|
||||
lookback_days = self.config.data_lookback_days
|
||||
|
||||
cache_key = f"{symbol}_{timeframe.value}"
|
||||
now = time.time()
|
||||
|
||||
cache_ttl = self.CANDLE_SECONDS.get(timeframe, self.config.refresh_interval)
|
||||
if (
|
||||
cache_key in self._cache_timestamps
|
||||
and (now - self._cache_timestamps[cache_key]) < self.config.refresh_interval
|
||||
and (now - self._cache_timestamps[cache_key]) < cache_ttl
|
||||
and cache_key in self._cache
|
||||
):
|
||||
cached = self._cache.get(cache_key)
|
||||
if cached is not None and not cached.empty:
|
||||
return cached
|
||||
|
||||
df = self._fetch_twelve_data(symbol, timeframe, lookback_days)
|
||||
outputsize = max(
|
||||
300,
|
||||
min(int(lookback_days * self.BARS_PER_DAY[timeframe]) + 20, 5000),
|
||||
)
|
||||
df = self._fetch_twelve_data(symbol, timeframe, outputsize)
|
||||
df = self._validate_and_clean(df, symbol, timeframe)
|
||||
|
||||
self._cache[cache_key] = df
|
||||
self._cache_timestamps[cache_key] = now
|
||||
return df
|
||||
|
||||
def prefetch_batch(
|
||||
self,
|
||||
symbols: List[str],
|
||||
timeframes: List[Timeframe],
|
||||
lookback_days: Optional[int] = None,
|
||||
) -> None:
|
||||
"""
|
||||
Batch-fetch all symbols for each timeframe in a single API call per TF.
|
||||
|
||||
Twelve Data accepts comma-separated symbols, so 7 pairs × 3 timeframes
|
||||
= 3 requests instead of 21 — well within the free-tier 8 req/min limit.
|
||||
Results are stored in the local cache; subsequent fetch_ohlcv calls
|
||||
for the same symbol/TF will be served from cache.
|
||||
"""
|
||||
if lookback_days is None:
|
||||
lookback_days = self.config.data_lookback_days
|
||||
|
||||
for tf in timeframes:
|
||||
try:
|
||||
self._batch_fetch_timeframe(symbols, tf, lookback_days)
|
||||
time.sleep(1.0) # brief pause between TF requests
|
||||
except Exception as e:
|
||||
logger.warning(f"Batch prefetch failed for {tf.value}: {e}")
|
||||
|
||||
def fetch_multiple(
|
||||
self,
|
||||
symbols: List[str],
|
||||
timeframe: Timeframe,
|
||||
lookback_days: Optional[int] = None,
|
||||
) -> Dict[str, pd.DataFrame]:
|
||||
"""Fetch data for multiple symbols, returning dict of DataFrames."""
|
||||
results = {}
|
||||
for symbol in symbols:
|
||||
try:
|
||||
df = self.fetch_ohlcv(symbol, timeframe, lookback_days)
|
||||
results[symbol] = df
|
||||
except Exception as e:
|
||||
logger.warning(f"Failed to fetch {symbol}: {e}")
|
||||
return results
|
||||
|
||||
def get_latest_price(self, symbol: str) -> Optional[float]:
|
||||
"""Return the most recent close price for a symbol."""
|
||||
def get_latest_price(self, symbol: str = USDJPY) -> Optional[float]:
|
||||
try:
|
||||
df = self.fetch_ohlcv(symbol, Timeframe.M5, lookback_days=1)
|
||||
if df is not None and not df.empty:
|
||||
@@ -168,47 +117,26 @@ class ForexDataProvider:
|
||||
pass
|
||||
return None
|
||||
|
||||
def get_spread_estimate(self, symbol: str) -> float:
|
||||
"""Estimate typical spread from recent M5 high-low ranges."""
|
||||
def get_spread_estimate(self, symbol: str = USDJPY) -> float:
|
||||
try:
|
||||
df = self.fetch_ohlcv(symbol, Timeframe.M5, lookback_days=1)
|
||||
if df is not None and not df.empty:
|
||||
return float((df["High"] - df["Low"]).median())
|
||||
except Exception:
|
||||
pass
|
||||
info = PAIR_INFO.get(symbol, PAIR_INFO[USDJPY])
|
||||
return info["pip_value"]
|
||||
|
||||
fallback_spreads = {
|
||||
"EURUSD=X": 0.00010, "GBPUSD=X": 0.00015,
|
||||
"USDJPY=X": 0.010, "USDCHF=X": 0.00015,
|
||||
"AUDUSD=X": 0.00015, "USDCAD=X": 0.00018,
|
||||
"NZDUSD=X": 0.00020,
|
||||
}
|
||||
return fallback_spreads.get(symbol, 0.00020)
|
||||
def get_pair_info(self, symbol: str = USDJPY) -> Dict:
|
||||
info = PAIR_INFO.get(symbol, PAIR_INFO[USDJPY])
|
||||
return {"symbol": symbol, **info}
|
||||
|
||||
def get_pair_info(self, symbol: str) -> Dict:
|
||||
"""Return display name and pip value for a pair."""
|
||||
display = SYMBOL_DISPLAY.get(symbol, symbol)
|
||||
is_jpy = "JPY" in symbol
|
||||
return {
|
||||
"symbol": symbol,
|
||||
"display": display,
|
||||
"pip_value": 0.01 if is_jpy else 0.0001,
|
||||
"is_jpy_pair": is_jpy,
|
||||
}
|
||||
|
||||
# ── Private Methods ────────────────────────────────────────────
|
||||
# ── Private ────────────────────────────────────────────────────
|
||||
|
||||
def _throttle(self, credits: int = 1) -> None:
|
||||
"""
|
||||
Block until `credits` API credits are available.
|
||||
|
||||
Twelve Data free tier: 8 credits/minute. Each symbol in any request
|
||||
(single or batch) consumes 1 credit. This method enforces the limit
|
||||
regardless of whether requests are batched or individual.
|
||||
"""
|
||||
"""Pro tier: 55 credits / minute. Block until budget allows."""
|
||||
while True:
|
||||
now = time.time()
|
||||
# Evict credits older than the rate window
|
||||
while self._request_times and now - self._request_times[0] >= self.RATE_WINDOW:
|
||||
self._request_times.popleft()
|
||||
|
||||
@@ -218,276 +146,76 @@ class ForexDataProvider:
|
||||
self._request_times.append(time.time())
|
||||
return
|
||||
|
||||
# Wait until the oldest credit expires
|
||||
wait = (self._request_times[0] + self.RATE_WINDOW) - now + 0.2
|
||||
logger.info(
|
||||
f"Rate limit: {len(self._request_times)}/{self.RATE_LIMIT} credits used "
|
||||
f"— waiting {wait:.1f}s for next window..."
|
||||
f"— waiting {wait:.1f}s..."
|
||||
)
|
||||
time.sleep(wait)
|
||||
|
||||
def _batch_fetch_timeframe(
|
||||
self, symbols: List[str], timeframe: Timeframe, lookback_days: int
|
||||
) -> None:
|
||||
"""
|
||||
Single API call fetching all symbols for one timeframe.
|
||||
Twelve Data returns a dict keyed by symbol when multiple are requested.
|
||||
Parsed DataFrames are validated and stored in the cache.
|
||||
"""
|
||||
if not self._api_key:
|
||||
return
|
||||
|
||||
td_symbols = [self._to_td_symbol(s) for s in symbols]
|
||||
interval = self.TD_INTERVALS[timeframe]
|
||||
outputsize = min(
|
||||
int(lookback_days * self.BARS_PER_DAY[timeframe]) + 20, 5000
|
||||
)
|
||||
outputsize = max(outputsize, 300)
|
||||
|
||||
# Each symbol in a batch request costs 1 credit
|
||||
self._throttle(credits=len(symbols))
|
||||
|
||||
resp = self._session.get(
|
||||
f"{self.TD_BASE_URL}/time_series",
|
||||
params={
|
||||
"symbol": ",".join(td_symbols),
|
||||
"interval": interval,
|
||||
"outputsize": outputsize,
|
||||
"apikey": self._api_key,
|
||||
"timezone": "UTC",
|
||||
"format": "json",
|
||||
},
|
||||
timeout=30,
|
||||
)
|
||||
resp.raise_for_status()
|
||||
data = resp.json()
|
||||
|
||||
# If the whole batch request returned a top-level error, raise it
|
||||
if isinstance(data, dict) and data.get("status") == "error":
|
||||
raise DataIntegrityError(
|
||||
f"Batch API error ({timeframe.value}): {data.get('message', 'unknown')}"
|
||||
)
|
||||
|
||||
# Batch response: {"EUR/USD": {...}, "GBP/USD": {...}, ...}
|
||||
now = time.time()
|
||||
for symbol, td_sym in zip(symbols, td_symbols):
|
||||
try:
|
||||
sym_data = data.get(td_sym, {})
|
||||
if sym_data.get("status") == "error":
|
||||
logger.warning(
|
||||
f"Batch fetch error for {td_sym}: {sym_data.get('message')}"
|
||||
)
|
||||
continue
|
||||
|
||||
values = sym_data.get("values")
|
||||
if not values:
|
||||
logger.warning(f"No values in batch response for {td_sym}")
|
||||
continue
|
||||
|
||||
records = [
|
||||
{
|
||||
"Datetime": pd.Timestamp(v["datetime"], tz="UTC"),
|
||||
"Open": float(v["open"]),
|
||||
"High": float(v["high"]),
|
||||
"Low": float(v["low"]),
|
||||
"Close": float(v["close"]),
|
||||
"Volume": float(v.get("volume") or 0),
|
||||
}
|
||||
for v in reversed(values)
|
||||
]
|
||||
df = pd.DataFrame(records).set_index("Datetime")
|
||||
df.index.name = "Datetime"
|
||||
df = self._validate_and_clean(df, symbol, timeframe)
|
||||
|
||||
cache_key = f"{symbol}_{timeframe.value}"
|
||||
self._cache[cache_key] = df
|
||||
self._cache_timestamps[cache_key] = now
|
||||
logger.debug(f"Batch cached {len(df)} bars for {td_sym} @ {interval}")
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Failed to parse batch data for {td_sym}: {e}")
|
||||
|
||||
def _fetch_twelve_data(
|
||||
self, symbol: str, timeframe: Timeframe, lookback_days: int
|
||||
self,
|
||||
symbol: str,
|
||||
timeframe: Timeframe,
|
||||
outputsize: int,
|
||||
start_date: Optional[str] = None,
|
||||
end_date: Optional[str] = None,
|
||||
) -> pd.DataFrame:
|
||||
"""
|
||||
Fetch OHLCV from Twelve Data REST API.
|
||||
Falls back to synthetic GBM data if API is unavailable or key is missing.
|
||||
"""
|
||||
if not self._api_key:
|
||||
logger.warning("No Twelve Data API key — using synthetic data. "
|
||||
"Set TWELVE_DATA_API_KEY env var or config.twelve_data_api_key.")
|
||||
return self._generate_synthetic_data(symbol, timeframe, lookback_days)
|
||||
if self._td is None:
|
||||
raise DataIntegrityError(
|
||||
"No Twelve Data API key. Set TWELVE_DATA_API_KEY env var "
|
||||
"or config.twelve_data_api_key."
|
||||
)
|
||||
|
||||
td_symbol = self._to_td_symbol(symbol)
|
||||
interval = self.TD_INTERVALS[timeframe]
|
||||
outputsize = min(
|
||||
int(lookback_days * self.BARS_PER_DAY[timeframe]) + 20,
|
||||
5000,
|
||||
)
|
||||
outputsize = max(outputsize, 300)
|
||||
|
||||
self._throttle(credits=1)
|
||||
|
||||
kwargs = {
|
||||
"symbol": td_symbol,
|
||||
"interval": interval,
|
||||
"outputsize": min(outputsize, 5000),
|
||||
"timezone": "UTC",
|
||||
}
|
||||
if start_date:
|
||||
kwargs["start_date"] = start_date
|
||||
if end_date:
|
||||
kwargs["end_date"] = end_date
|
||||
|
||||
try:
|
||||
resp = self._session.get(
|
||||
f"{self.TD_BASE_URL}/time_series",
|
||||
params={
|
||||
"symbol": td_symbol,
|
||||
"interval": interval,
|
||||
"outputsize": outputsize,
|
||||
"apikey": self._api_key,
|
||||
"timezone": "UTC",
|
||||
"format": "json",
|
||||
},
|
||||
timeout=15,
|
||||
)
|
||||
resp.raise_for_status()
|
||||
data = resp.json()
|
||||
|
||||
if data.get("status") == "error":
|
||||
raise DataIntegrityError(
|
||||
f"Twelve Data API error for {td_symbol}: {data.get('message', 'unknown')}"
|
||||
)
|
||||
|
||||
values = data.get("values")
|
||||
if not values:
|
||||
raise DataIntegrityError(f"Empty response from Twelve Data for {td_symbol}")
|
||||
|
||||
# Values arrive newest-first; reverse to chronological order
|
||||
records = [
|
||||
{
|
||||
"Datetime": pd.Timestamp(v["datetime"], tz="UTC"),
|
||||
"Open": float(v["open"]),
|
||||
"High": float(v["high"]),
|
||||
"Low": float(v["low"]),
|
||||
"Close": float(v["close"]),
|
||||
"Volume": float(v.get("volume") or 0),
|
||||
}
|
||||
for v in reversed(values)
|
||||
]
|
||||
|
||||
df = pd.DataFrame(records).set_index("Datetime")
|
||||
df.index.name = "Datetime"
|
||||
logger.debug(f"Fetched {len(df)} bars for {td_symbol} @ {interval}")
|
||||
return df
|
||||
|
||||
except DataIntegrityError:
|
||||
raise
|
||||
df = self._td.time_series(**kwargs).as_pandas()
|
||||
except Exception as e:
|
||||
logger.info(f"Twelve Data fetch failed for {symbol} ({e}), using synthetic data.")
|
||||
return self._generate_synthetic_data(symbol, timeframe, lookback_days)
|
||||
raise DataIntegrityError(
|
||||
f"Twelve Data fetch failed for {td_symbol}: {e}"
|
||||
) from e
|
||||
|
||||
def _generate_synthetic_data(
|
||||
self, symbol: str, timeframe: Timeframe, lookback_days: int
|
||||
) -> pd.DataFrame:
|
||||
"""
|
||||
Generate realistic synthetic Forex OHLCV using GBM with mean-reversion.
|
||||
Used as a fallback when live data is unavailable.
|
||||
"""
|
||||
pair_params = {
|
||||
"EURUSD=X": {"price": 1.1350, "vol": 0.07, "drift": -0.001},
|
||||
"GBPUSD=X": {"price": 1.3200, "vol": 0.08, "drift": 0.002},
|
||||
"USDJPY=X": {"price": 144.50, "vol": 0.09, "drift": 0.003},
|
||||
"USDCHF=X": {"price": 0.8850, "vol": 0.07, "drift": -0.001},
|
||||
"AUDUSD=X": {"price": 0.6550, "vol": 0.10, "drift": -0.002},
|
||||
"USDCAD=X": {"price": 1.3650, "vol": 0.07, "drift": 0.001},
|
||||
"NZDUSD=X": {"price": 0.6100, "vol": 0.10, "drift": -0.001},
|
||||
"EURGBP=X": {"price": 0.8590, "vol": 0.06, "drift": 0.000},
|
||||
"EURJPY=X": {"price": 163.90, "vol": 0.09, "drift": 0.002},
|
||||
"GBPJPY=X": {"price": 190.70, "vol": 0.11, "drift": 0.003},
|
||||
"AUDJPY=X": {"price": 94.60, "vol": 0.11, "drift": 0.001},
|
||||
"EURCHF=X": {"price": 0.9380, "vol": 0.05, "drift": 0.000},
|
||||
"CADJPY=X": {"price": 105.80, "vol": 0.09, "drift": 0.001},
|
||||
}
|
||||
if df is None or df.empty:
|
||||
raise DataIntegrityError(f"Empty response from Twelve Data for {td_symbol}")
|
||||
|
||||
params = pair_params.get(symbol, {"price": 1.0000, "vol": 0.08, "drift": 0.000})
|
||||
base_price = params["price"]
|
||||
annual_vol = params["vol"]
|
||||
annual_drift = params["drift"]
|
||||
# SDK returns lowercase columns; engine expects capitalised.
|
||||
df = df.rename(columns={
|
||||
"open": "Open", "high": "High", "low": "Low",
|
||||
"close": "Close", "volume": "Volume",
|
||||
})
|
||||
for col in ("Open", "High", "Low", "Close", "Volume"):
|
||||
if col in df.columns:
|
||||
df[col] = pd.to_numeric(df[col], errors="coerce")
|
||||
if "Volume" not in df.columns:
|
||||
df["Volume"] = 0.0
|
||||
|
||||
tf_minutes = {
|
||||
Timeframe.M1: 1, Timeframe.M5: 5, Timeframe.M15: 15,
|
||||
Timeframe.M30: 30, Timeframe.H1: 60, Timeframe.H4: 240,
|
||||
Timeframe.D1: 1440, Timeframe.W1: 10080,
|
||||
}
|
||||
bar_minutes = tf_minutes.get(timeframe, 60)
|
||||
bars_per_year = (365.25 * 24 * 60) / bar_minutes
|
||||
dt = 1.0 / bars_per_year
|
||||
|
||||
n_bars = min(int(lookback_days * 24 * 60 / bar_minutes), 2000)
|
||||
n_bars = max(n_bars, 300)
|
||||
|
||||
seed_base = int(hashlib.md5(symbol.encode()).hexdigest()[:8], 16)
|
||||
time_component = int(time.time()) // 3600
|
||||
np.random.seed((seed_base + time_component) % (2**31))
|
||||
|
||||
bar_vol = annual_vol * np.sqrt(dt)
|
||||
bar_drift = annual_drift * dt
|
||||
|
||||
regime_len = np.random.randint(20, 80)
|
||||
trend_strength = np.random.normal(0, 0.3)
|
||||
|
||||
price = base_price
|
||||
prices = [price]
|
||||
|
||||
for i in range(1, n_bars):
|
||||
if i % regime_len == 0:
|
||||
regime_len = np.random.randint(20, 80)
|
||||
trend_strength = np.random.normal(0, 0.3)
|
||||
|
||||
mr_force = -0.001 * (price - base_price) / base_price
|
||||
ret = bar_drift + trend_strength * dt + mr_force + bar_vol * np.random.randn()
|
||||
|
||||
if np.random.random() < 0.02:
|
||||
ret *= np.random.uniform(2.0, 4.0)
|
||||
|
||||
price *= (1 + ret)
|
||||
prices.append(price)
|
||||
|
||||
prices = np.array(prices)
|
||||
opens = np.roll(prices, 1)
|
||||
opens[0] = prices[0]
|
||||
|
||||
typical_range = bar_vol * base_price * 1.5
|
||||
highs = np.maximum(prices, opens) + np.abs(np.random.normal(0, typical_range * 0.6, n_bars))
|
||||
lows = np.minimum(prices, opens) - np.abs(np.random.normal(0, typical_range * 0.6, n_bars))
|
||||
highs = np.maximum(highs, np.maximum(opens, prices))
|
||||
lows = np.minimum(lows, np.minimum(opens, prices))
|
||||
|
||||
volume = np.random.lognormal(mean=10, sigma=0.5, size=n_bars).astype(int)
|
||||
|
||||
freq_map = {
|
||||
Timeframe.M1: "1min", Timeframe.M5: "5min",
|
||||
Timeframe.M15: "15min", Timeframe.M30: "30min",
|
||||
Timeframe.H1: "1h", Timeframe.H4: "4h",
|
||||
Timeframe.D1: "D", Timeframe.W1: "W",
|
||||
}
|
||||
freq = freq_map.get(timeframe, "1h")
|
||||
end_time = pd.Timestamp.now(tz="UTC").floor(f"{bar_minutes}min")
|
||||
index = pd.date_range(end=end_time, periods=n_bars, freq=freq, tz="UTC")
|
||||
|
||||
df = pd.DataFrame({
|
||||
"Open": opens, "High": highs, "Low": lows,
|
||||
"Close": prices, "Volume": volume,
|
||||
}, index=index)
|
||||
# SDK returns newest-first; engine + indicators want oldest-first.
|
||||
df = df.sort_index()
|
||||
if df.index.tz is None:
|
||||
df.index = df.index.tz_localize("UTC")
|
||||
df.index.name = "Datetime"
|
||||
|
||||
logger.info(
|
||||
f"Generated {n_bars} synthetic {timeframe.value} bars for "
|
||||
f"{SYMBOL_DISPLAY.get(symbol, symbol)} @ {prices[-1]:.5f}"
|
||||
)
|
||||
logger.debug(f"Fetched {len(df)} bars for {td_symbol} @ {interval}")
|
||||
return df
|
||||
|
||||
def _validate_and_clean(
|
||||
self, df: pd.DataFrame, symbol: str, timeframe: Timeframe
|
||||
) -> pd.DataFrame:
|
||||
"""
|
||||
Validate and clean OHLCV data.
|
||||
|
||||
Steps: drop all-NaN rows → ffill small gaps → remove future timestamps
|
||||
→ fix OHLC inconsistencies → remove >10-sigma outliers → sort & deduplicate.
|
||||
"""
|
||||
if df is None or df.empty:
|
||||
raise DataIntegrityError(f"Empty dataset for {symbol}")
|
||||
|
||||
|
||||
@@ -83,18 +83,19 @@ class TechnicalEngine:
|
||||
)
|
||||
|
||||
# ── Compute all indicators ─────────────────────────────────
|
||||
self._compute_ema_signals(df, result)
|
||||
self._compute_rsi(df, result)
|
||||
self._compute_macd(df, result)
|
||||
self._compute_bollinger(df, result)
|
||||
self._compute_stochastic(df, result)
|
||||
self._compute_adx(df, result)
|
||||
self._compute_atr(df, result)
|
||||
self._compute_ichimoku(df, result)
|
||||
self._detect_divergences(df, result)
|
||||
self._detect_candlestick_patterns(df, result)
|
||||
self._compute_support_resistance(df, result)
|
||||
self._compute_volume_analysis(df, result)
|
||||
disabled = set(self.config.disabled_indicators or [])
|
||||
|
||||
if "ema_trend" not in disabled: self._compute_ema_signals(df, result)
|
||||
if "rsi" not in disabled: self._compute_rsi(df, result)
|
||||
if "bollinger" not in disabled: self._compute_bollinger(df, result)
|
||||
if "adx" not in disabled: self._compute_adx(df, result)
|
||||
if "atr" not in disabled: self._compute_atr(df, result)
|
||||
|
||||
self._compute_macd_internal(df, result)
|
||||
|
||||
if "divergence" not in disabled: self._detect_divergences(df, result)
|
||||
if "structure" not in disabled: self._compute_structure_sr(df, result)
|
||||
if "candlestick" not in disabled: self._detect_candlestick_patterns(df, result)
|
||||
|
||||
# ── Classify market regime ─────────────────────────────────
|
||||
self._classify_regime(df, result)
|
||||
@@ -169,8 +170,13 @@ class TechnicalEngine:
|
||||
result.indicators["ema_trend"] = IndicatorSignal(
|
||||
name="EMA Trend", value=normalized,
|
||||
signal=signal, confidence=conf,
|
||||
description=desc, weight=1.2,
|
||||
description=desc, weight=1.0,
|
||||
)
|
||||
if t is not None:
|
||||
result.key_levels["ema_trend"] = float(t)
|
||||
result.key_levels["ema_fast"] = float(f)
|
||||
result.key_levels["ema_medium"] = float(m)
|
||||
result.key_levels["ema_slow"] = float(s)
|
||||
|
||||
def _compute_rsi(self, df: pd.DataFrame, result: TechnicalAnalysis):
|
||||
"""RSI with trend-adjusted interpretation."""
|
||||
@@ -215,14 +221,14 @@ class TechnicalEngine:
|
||||
|
||||
result.indicators["rsi"] = IndicatorSignal(
|
||||
name="RSI", value=rsi_val, signal=signal,
|
||||
confidence=conf, description=desc, weight=1.0,
|
||||
confidence=conf, description=desc, weight=1.5,
|
||||
)
|
||||
|
||||
# Attach RSI series for divergence detection (dynamic attribute, filtered by _prefix)
|
||||
result._rsi_series = rsi # type: ignore[attr-defined]
|
||||
|
||||
def _compute_macd(self, df: pd.DataFrame, result: TechnicalAnalysis):
|
||||
"""MACD with histogram momentum analysis."""
|
||||
def _compute_macd_internal(self, df: pd.DataFrame, result: TechnicalAnalysis):
|
||||
"""Compute MACD histogram internally for divergence detection (not a signal pillar)."""
|
||||
c = self.config
|
||||
close = df["Close"]
|
||||
|
||||
@@ -232,62 +238,6 @@ class TechnicalEngine:
|
||||
signal_line = macd_line.ewm(span=c.macd_signal, adjust=False).mean()
|
||||
histogram = macd_line - signal_line
|
||||
|
||||
macd_val = macd_line.iloc[-1]
|
||||
signal_val = signal_line.iloc[-1]
|
||||
hist_val = histogram.iloc[-1]
|
||||
|
||||
# Check for crossover
|
||||
crossover = False
|
||||
crossover_type = ""
|
||||
if len(macd_line) >= 2:
|
||||
prev_macd = macd_line.iloc[-2]
|
||||
prev_signal = signal_line.iloc[-2]
|
||||
if prev_macd <= prev_signal and macd_val > signal_val:
|
||||
crossover = True
|
||||
crossover_type = "bullish"
|
||||
elif prev_macd >= prev_signal and macd_val < signal_val:
|
||||
crossover = True
|
||||
crossover_type = "bearish"
|
||||
|
||||
# Histogram momentum (is it expanding or contracting?)
|
||||
hist_momentum = ""
|
||||
if len(histogram) >= 3:
|
||||
h1, h2, h3 = histogram.iloc[-3], histogram.iloc[-2], histogram.iloc[-1]
|
||||
if h3 > h2 > h1 and h3 > 0:
|
||||
hist_momentum = "accelerating bullish"
|
||||
elif h3 < h2 < h1 and h3 < 0:
|
||||
hist_momentum = "accelerating bearish"
|
||||
elif abs(h3) < abs(h2) and h3 * h2 > 0:
|
||||
hist_momentum = "decelerating"
|
||||
|
||||
# Signal
|
||||
if crossover and crossover_type == "bullish":
|
||||
signal = SignalStrength.STRONG_BUY
|
||||
conf = 75
|
||||
desc = f"MACD bullish crossover | Hist: {hist_val:.6f}"
|
||||
elif crossover and crossover_type == "bearish":
|
||||
signal = SignalStrength.STRONG_SELL
|
||||
conf = 75
|
||||
desc = f"MACD bearish crossover | Hist: {hist_val:.6f}"
|
||||
elif macd_val > signal_val and hist_val > 0:
|
||||
signal = SignalStrength.BUY
|
||||
conf = 55
|
||||
desc = f"MACD above signal, positive histogram | {hist_momentum}"
|
||||
elif macd_val < signal_val and hist_val < 0:
|
||||
signal = SignalStrength.SELL
|
||||
conf = 55
|
||||
desc = f"MACD below signal, negative histogram | {hist_momentum}"
|
||||
else:
|
||||
signal = SignalStrength.NEUTRAL
|
||||
conf = 35
|
||||
desc = f"MACD mixed | Hist: {hist_val:.6f}"
|
||||
|
||||
result.indicators["macd"] = IndicatorSignal(
|
||||
name="MACD", value=hist_val, signal=signal,
|
||||
confidence=conf, description=desc, weight=1.1,
|
||||
)
|
||||
|
||||
# Attach histogram for divergence detection
|
||||
result._macd_histogram = histogram # type: ignore[attr-defined]
|
||||
|
||||
def _compute_bollinger(self, df: pd.DataFrame, result: TechnicalAnalysis):
|
||||
@@ -351,7 +301,7 @@ class TechnicalEngine:
|
||||
|
||||
result.indicators["bollinger"] = IndicatorSignal(
|
||||
name="Bollinger Bands", value=bb_position, signal=signal,
|
||||
confidence=conf, description=desc, weight=0.9,
|
||||
confidence=conf, description=desc, weight=1.5,
|
||||
)
|
||||
|
||||
result.key_levels["bb_upper"] = upper_val
|
||||
@@ -416,7 +366,7 @@ class TechnicalEngine:
|
||||
|
||||
result.indicators["stochastic"] = IndicatorSignal(
|
||||
name="Stochastic", value=k_val, signal=signal,
|
||||
confidence=conf, description=desc, weight=0.8,
|
||||
confidence=conf, description=desc, weight=2.5,
|
||||
)
|
||||
|
||||
def _compute_adx(self, df: pd.DataFrame, result: TechnicalAnalysis):
|
||||
@@ -476,7 +426,7 @@ class TechnicalEngine:
|
||||
|
||||
result.indicators["adx"] = IndicatorSignal(
|
||||
name="ADX", value=adx_val, signal=signal,
|
||||
confidence=conf, description=desc, weight=1.0,
|
||||
confidence=conf, description=desc, weight=0.5,
|
||||
)
|
||||
|
||||
def _compute_atr(self, df: pd.DataFrame, result: TechnicalAnalysis):
|
||||
@@ -602,7 +552,7 @@ class TechnicalEngine:
|
||||
name="Ichimoku", value=float(score), signal=signal,
|
||||
confidence=conf,
|
||||
description=f"Ichimoku [{score}/4]: {' | '.join(signals)}",
|
||||
weight=1.1,
|
||||
weight=0.3,
|
||||
)
|
||||
|
||||
result.key_levels["ichimoku_cloud_top"] = cloud_top
|
||||
@@ -665,11 +615,39 @@ class TechnicalEngine:
|
||||
name="Divergence", value=len(divergences),
|
||||
signal=signal, confidence=70,
|
||||
description=" | ".join(divergences),
|
||||
weight=1.5, # divergences are strong reversal signals
|
||||
weight=1.0,
|
||||
)
|
||||
# Note: divergences are NOT added to pattern_signals to avoid
|
||||
# duplicate reason collection (the indicator entry covers them).
|
||||
|
||||
def _compute_structure_sr(self, df: pd.DataFrame, result: TechnicalAnalysis):
|
||||
"""Detect swing high/low structure levels for S/R and trade setup."""
|
||||
lookback = min(self.config.swing_sr_lookback, len(df) - 1)
|
||||
if lookback < 10:
|
||||
return
|
||||
|
||||
price = df["Close"].iloc[-1]
|
||||
high_window = df["High"].iloc[-lookback:]
|
||||
low_window = df["Low"].iloc[-lookback:]
|
||||
|
||||
swing_highs = self._find_swing_points(high_window, mode="high", window=3)
|
||||
swing_lows = self._find_swing_points(low_window, mode="low", window=3)
|
||||
|
||||
highs_above = sorted([v for _, v in swing_highs if v > price])
|
||||
highs_below = sorted([v for _, v in swing_highs if v <= price], reverse=True)
|
||||
lows_below = sorted([v for _, v in swing_lows if v < price], reverse=True)
|
||||
lows_above = sorted([v for _, v in swing_lows if v >= price])
|
||||
|
||||
for i, val in enumerate(highs_above[:3], 1):
|
||||
result.key_levels[f"swing_high_{i}"] = float(val)
|
||||
for i, val in enumerate(lows_below[:3], 1):
|
||||
result.key_levels[f"swing_low_{i}"] = float(val)
|
||||
|
||||
if not highs_above and highs_below:
|
||||
result.key_levels["swing_high_1"] = float(highs_below[0])
|
||||
if not lows_below and lows_above:
|
||||
result.key_levels["swing_low_1"] = float(lows_above[0])
|
||||
|
||||
def _detect_candlestick_patterns(self, df: pd.DataFrame, result: TechnicalAnalysis):
|
||||
"""Detect significant candlestick patterns on recent bars."""
|
||||
if len(df) < 5:
|
||||
@@ -731,11 +709,33 @@ class TechnicalEngine:
|
||||
else:
|
||||
signal = SignalStrength.NEUTRAL
|
||||
|
||||
conf = 50
|
||||
atr_val = result.key_levels.get("atr", 0)
|
||||
latest = c
|
||||
proximity = atr_val * 0.5 if atr_val > 0 else 0
|
||||
|
||||
if proximity > 0:
|
||||
swing_lows = sorted(
|
||||
[v for k, v in result.key_levels.items() if k.startswith("swing_low_")]
|
||||
)
|
||||
swing_highs = sorted(
|
||||
[v for k, v in result.key_levels.items() if k.startswith("swing_high_")]
|
||||
)
|
||||
near_support = any(abs(latest - sl) <= proximity for sl in swing_lows)
|
||||
near_resistance = any(abs(latest - sh) <= proximity for sh in swing_highs)
|
||||
|
||||
if bullish > bearish and near_support:
|
||||
conf += 20
|
||||
patterns.append("(at support)")
|
||||
elif bearish > bullish and near_resistance:
|
||||
conf += 20
|
||||
patterns.append("(at resistance)")
|
||||
|
||||
result.indicators["candlestick"] = IndicatorSignal(
|
||||
name="Candlestick", value=float(bullish - bearish),
|
||||
signal=signal, confidence=50,
|
||||
signal=signal, confidence=conf,
|
||||
description=" | ".join(patterns),
|
||||
weight=0.7,
|
||||
weight=1.5,
|
||||
)
|
||||
result.pattern_signals.extend(patterns)
|
||||
|
||||
@@ -777,7 +777,7 @@ class TechnicalEngine:
|
||||
result.indicators["pivot"] = IndicatorSignal(
|
||||
name="Pivot Points", value=pivot,
|
||||
signal=SignalStrength.BUY if latest > pivot else SignalStrength.SELL,
|
||||
confidence=45, description=desc, weight=0.6,
|
||||
confidence=45, description=desc, weight=0.8,
|
||||
)
|
||||
|
||||
def _compute_volume_analysis(self, df: pd.DataFrame, result: TechnicalAnalysis):
|
||||
@@ -847,10 +847,18 @@ class TechnicalEngine:
|
||||
total_weight = 0.0
|
||||
total_confidence = 0.0
|
||||
|
||||
_trending = {
|
||||
"ema_trend": 2.0, "rsi": 1.5, "bollinger": 0.8,
|
||||
"candlestick": 1.5, "divergence": 1.0,
|
||||
}
|
||||
regime_weights = {
|
||||
"trending_up": {"ema_trend": 1.5, "adx": 1.3, "macd": 1.2, "rsi": 0.7, "bollinger": 0.6},
|
||||
"trending_down": {"ema_trend": 1.5, "adx": 1.3, "macd": 1.2, "rsi": 0.7, "bollinger": 0.6},
|
||||
"ranging": {"rsi": 1.4, "stochastic": 1.3, "bollinger": 1.4, "ema_trend": 0.6, "adx": 0.5},
|
||||
"trending_up": _trending,
|
||||
"trending_down": _trending,
|
||||
"trending": _trending,
|
||||
"ranging": {
|
||||
"ema_trend": 0.5, "rsi": 2.0, "bollinger": 2.0,
|
||||
"candlestick": 1.5, "divergence": 1.5,
|
||||
},
|
||||
}
|
||||
|
||||
active_regime_weights = regime_weights.get(result.market_regime, {})
|
||||
|
||||
@@ -1,509 +1,320 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Forex Signal Intelligence Platform
|
||||
====================================
|
||||
Main entry point. Runs full analysis and outputs formatted signal reports.
|
||||
|
||||
Usage:
|
||||
python main.py # Analyze all major pairs
|
||||
python main.py --pairs EURUSD GBPUSD # Specific pairs
|
||||
python main.py --timeframe H4 # Different primary TF
|
||||
python main.py --json # JSON output
|
||||
python main.py --watch # Continuous monitoring mode
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import sys
|
||||
import time
|
||||
from datetime import datetime, timezone
|
||||
from typing import List
|
||||
|
||||
# Force UTF-8 output on Windows so box-drawing / Unicode chars render correctly
|
||||
if hasattr(sys.stdout, "reconfigure"):
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
if hasattr(sys.stderr, "reconfigure"):
|
||||
sys.stderr.reconfigure(encoding="utf-8")
|
||||
|
||||
from config import (
|
||||
PlatformConfig, Timeframe, SignalStrength,
|
||||
MAJOR_PAIRS, CROSS_PAIRS,
|
||||
)
|
||||
from signal_aggregator import SignalAggregator, SignalReport
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════
|
||||
# TERMINAL FORMATTING
|
||||
# ══════════════════════════════════════════════════════════════════
|
||||
|
||||
class Colors:
|
||||
"""ANSI color codes for terminal output."""
|
||||
RESET = "\033[0m"
|
||||
BOLD = "\033[1m"
|
||||
DIM = "\033[2m"
|
||||
UNDERLINE = "\033[4m"
|
||||
|
||||
RED = "\033[91m"
|
||||
GREEN = "\033[92m"
|
||||
YELLOW = "\033[93m"
|
||||
BLUE = "\033[94m"
|
||||
MAGENTA = "\033[95m"
|
||||
CYAN = "\033[96m"
|
||||
WHITE = "\033[97m"
|
||||
GRAY = "\033[90m"
|
||||
|
||||
BG_RED = "\033[41m"
|
||||
BG_GREEN = "\033[42m"
|
||||
BG_YELLOW = "\033[43m"
|
||||
BG_BLUE = "\033[44m"
|
||||
BG_MAGENTA = "\033[45m"
|
||||
BG_CYAN = "\033[46m"
|
||||
|
||||
|
||||
def signal_color(signal: SignalStrength) -> str:
|
||||
"""Get color for a signal strength."""
|
||||
return {
|
||||
SignalStrength.STRONG_BUY: Colors.GREEN + Colors.BOLD,
|
||||
SignalStrength.BUY: Colors.GREEN,
|
||||
SignalStrength.NEUTRAL: Colors.GRAY,
|
||||
SignalStrength.SELL: Colors.RED,
|
||||
SignalStrength.STRONG_SELL: Colors.RED + Colors.BOLD,
|
||||
}.get(signal, Colors.RESET)
|
||||
|
||||
|
||||
def quality_color(quality: str) -> str:
|
||||
"""Get color for signal quality grade."""
|
||||
return {
|
||||
"A+": Colors.GREEN + Colors.BOLD,
|
||||
"A": Colors.GREEN,
|
||||
"B": Colors.CYAN,
|
||||
"C": Colors.YELLOW,
|
||||
"D": Colors.GRAY,
|
||||
"F": Colors.DIM,
|
||||
}.get(quality, Colors.RESET)
|
||||
|
||||
|
||||
def score_bar(score: float, width: int = 30) -> str:
|
||||
"""Create a visual score bar from -100 to +100."""
|
||||
normalized = (score + 100) / 200 # 0 to 1
|
||||
filled = int(normalized * width)
|
||||
center = width // 2
|
||||
|
||||
bar = ""
|
||||
for i in range(width):
|
||||
if i == center:
|
||||
bar += "│"
|
||||
elif (score >= 0 and center < i <= filled) or \
|
||||
(score < 0 and filled <= i < center):
|
||||
bar += "█"
|
||||
else:
|
||||
bar += "░"
|
||||
|
||||
if score >= 0:
|
||||
color = Colors.GREEN if score > 20 else Colors.GRAY
|
||||
else:
|
||||
color = Colors.RED if score < -20 else Colors.GRAY
|
||||
|
||||
return f"{color}{bar}{Colors.RESET}"
|
||||
|
||||
|
||||
def print_header():
|
||||
"""Print the platform header."""
|
||||
now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
|
||||
width = 80
|
||||
|
||||
print(f"\n{Colors.CYAN}{'═' * width}{Colors.RESET}")
|
||||
print(f"{Colors.BOLD}{Colors.CYAN} ╔═══════════════════════════════════════════════════════╗{Colors.RESET}")
|
||||
print(f"{Colors.BOLD}{Colors.CYAN} ║ FOREX SIGNAL INTELLIGENCE PLATFORM ║{Colors.RESET}")
|
||||
print(f"{Colors.BOLD}{Colors.CYAN} ║ Multi-Layer Signal Analysis Engine ║{Colors.RESET}")
|
||||
print(f"{Colors.BOLD}{Colors.CYAN} ╚═══════════════════════════════════════════════════════╝{Colors.RESET}")
|
||||
print(f"{Colors.GRAY} Scan Time: {now}{Colors.RESET}")
|
||||
print(f"{Colors.CYAN}{'═' * width}{Colors.RESET}\n")
|
||||
|
||||
|
||||
def print_summary_table(reports: List[SignalReport]):
|
||||
"""Print a summary table of all pairs."""
|
||||
print(f"{Colors.BOLD}{Colors.WHITE} ┌─────────────┬───────────┬──────────────────────────────────┬────────┬────────────┐{Colors.RESET}")
|
||||
print(f"{Colors.BOLD}{Colors.WHITE} │ Pair │ Signal │ Score │ Grade │ Confidence │{Colors.RESET}")
|
||||
print(f"{Colors.BOLD}{Colors.WHITE} ├─────────────┼───────────┼──────────────────────────────────┼────────┼────────────┤{Colors.RESET}")
|
||||
|
||||
for r in reports:
|
||||
sig = r.final_signal.name.replace("_", " ")
|
||||
sc = signal_color(r.final_signal)
|
||||
qc = quality_color(r.signal_quality)
|
||||
bar = score_bar(r.final_score, 30)
|
||||
|
||||
pair = f"{r.display_name:<11}"
|
||||
signal_str = f"{sc}{sig:<9}{Colors.RESET}"
|
||||
grade_str = f"{qc}{r.signal_quality:<6}{Colors.RESET}"
|
||||
conf_str = f"{r.final_confidence:5.1f}%"
|
||||
|
||||
# Add warning indicator
|
||||
warn = ""
|
||||
if r.event_risk == "danger":
|
||||
warn = f" {Colors.RED}⚠{Colors.RESET}"
|
||||
elif r.event_risk == "caution":
|
||||
warn = f" {Colors.YELLOW}△{Colors.RESET}"
|
||||
|
||||
print(f" │ {pair} │ {signal_str} │ {bar} │ {grade_str} │ {conf_str:>8}{warn} │")
|
||||
|
||||
print(f"{Colors.BOLD}{Colors.WHITE} └─────────────┴───────────┴──────────────────────────────────┴────────┴────────────┘{Colors.RESET}")
|
||||
|
||||
# Legend
|
||||
print(f"\n{Colors.GRAY} Legend: "
|
||||
f"{Colors.GREEN}██ Bullish{Colors.GRAY} | "
|
||||
f"{Colors.RED}██ Bearish{Colors.GRAY} | "
|
||||
f"│ Center (0) | "
|
||||
f"{Colors.RED}⚠ Event Risk{Colors.GRAY} | "
|
||||
f"{Colors.YELLOW}△ Caution{Colors.RESET}")
|
||||
|
||||
|
||||
def print_detailed_report(report: SignalReport):
|
||||
"""Print detailed analysis for a single pair."""
|
||||
sc = signal_color(report.final_signal)
|
||||
qc = quality_color(report.signal_quality)
|
||||
sig_name = report.final_signal.name.replace("_", " ")
|
||||
|
||||
print(f"\n{Colors.CYAN}{'─' * 80}{Colors.RESET}")
|
||||
print(f" {Colors.BOLD}{Colors.WHITE}{report.display_name}{Colors.RESET}"
|
||||
f" │ Price: {Colors.BOLD}{report.current_price:.5f}{Colors.RESET}"
|
||||
f" │ Regime: {Colors.CYAN}{report.market_regime}{Colors.RESET}"
|
||||
f" │ Vol: {report.volatility_regime}")
|
||||
|
||||
print(f"\n {Colors.BOLD}SIGNAL:{Colors.RESET} {sc}{sig_name}{Colors.RESET}"
|
||||
f" │ Score: {sc}{report.final_score:+.1f}{Colors.RESET}"
|
||||
f" │ Grade: {qc}{report.signal_quality}{Colors.RESET}"
|
||||
f" │ Confidence: {report.final_confidence:.0f}%")
|
||||
|
||||
print(f" {Colors.BOLD}Action:{Colors.RESET} {report.action_recommendation}")
|
||||
|
||||
# Multi-timeframe breakdown
|
||||
if report.mtf_signals:
|
||||
print(f"\n {Colors.BOLD}Multi-Timeframe:{Colors.RESET}", end="")
|
||||
mtf_agree = f" {Colors.GREEN}✓ ALIGNED{Colors.RESET}" if report.mtf_agreement else f" {Colors.YELLOW}✗ DIVERGENT{Colors.RESET}"
|
||||
print(mtf_agree)
|
||||
for tf, sig in report.mtf_signals.items():
|
||||
tf_sc = signal_color(sig)
|
||||
tf_score = report.mtf_scores.get(tf, 0)
|
||||
print(f" {tf:>5}: {tf_sc}{sig.name.replace('_', ' '):<12}{Colors.RESET} ({tf_score:+.1f})")
|
||||
|
||||
# Indicators detail
|
||||
if report.primary_analysis:
|
||||
print(f"\n {Colors.BOLD}Indicators ({report.primary_analysis.timeframe}):{Colors.RESET}")
|
||||
for name, ind in report.primary_analysis.indicators.items():
|
||||
if name.startswith("_") or ind.weight == 0:
|
||||
continue
|
||||
isc = signal_color(ind.signal)
|
||||
ind_name = f"{ind.name:<18}"
|
||||
print(f" {ind_name} {isc}{ind.signal.name.replace('_', ' '):<12}{Colors.RESET}"
|
||||
f" ({ind.confidence:.0f}%) │ {Colors.GRAY}{ind.description}{Colors.RESET}")
|
||||
|
||||
# Bullish reasons
|
||||
if report.bullish_reasons:
|
||||
print(f"\n {Colors.GREEN}▲ Bullish Factors:{Colors.RESET}")
|
||||
for reason in report.bullish_reasons[:5]:
|
||||
print(f" {Colors.GREEN}+{Colors.RESET} {reason}")
|
||||
|
||||
# Bearish reasons
|
||||
if report.bearish_reasons:
|
||||
print(f"\n {Colors.RED}▼ Bearish Factors:{Colors.RESET}")
|
||||
for reason in report.bearish_reasons[:5]:
|
||||
print(f" {Colors.RED}-{Colors.RESET} {reason}")
|
||||
|
||||
# Warnings
|
||||
if report.warnings:
|
||||
print(f"\n {Colors.YELLOW}⚠ Warnings:{Colors.RESET}")
|
||||
for warning in report.warnings:
|
||||
print(f" {Colors.YELLOW}!{Colors.RESET} {warning}")
|
||||
|
||||
# News context
|
||||
if report.news_description and report.news_description != "Neutral news sentiment":
|
||||
print(f"\n {Colors.MAGENTA}📰 News:{Colors.RESET} {report.news_description}")
|
||||
if report.event_description and report.event_risk != "clear":
|
||||
print(f" {Colors.YELLOW}📅 Event:{Colors.RESET} {report.event_description}")
|
||||
|
||||
# Trade setup
|
||||
if report.trade_setup:
|
||||
ts = report.trade_setup
|
||||
dir_color = Colors.GREEN if ts.direction == "BUY" else Colors.RED
|
||||
print(f"\n {Colors.BOLD}Trade Setup:{Colors.RESET}")
|
||||
print(f" Direction: {dir_color}{ts.direction}{Colors.RESET}")
|
||||
print(f" Entry: {ts.entry_price:.5f}")
|
||||
print(f" Stop Loss: {Colors.RED}{ts.stop_loss:.5f}{Colors.RESET} ({ts.risk_pips:.1f} pips)")
|
||||
print(f" Take Profit 1: {Colors.GREEN}{ts.take_profit_1:.5f}{Colors.RESET} ({ts.reward_pips:.1f} pips)")
|
||||
print(f" Take Profit 2: {Colors.GREEN}{ts.take_profit_2:.5f}{Colors.RESET}")
|
||||
print(f" Risk:Reward: 1:{ts.risk_reward:.1f}")
|
||||
|
||||
# Key levels
|
||||
if report.primary_analysis and report.primary_analysis.key_levels:
|
||||
levels = report.primary_analysis.key_levels
|
||||
print(f"\n {Colors.BOLD}Key Levels:{Colors.RESET}")
|
||||
level_names = ["r3", "r2", "r1", "pivot", "s1", "s2", "s3"]
|
||||
for lvl in level_names:
|
||||
if lvl in levels:
|
||||
val = levels[lvl]
|
||||
if val > report.current_price:
|
||||
color = Colors.RED # resistance
|
||||
else:
|
||||
color = Colors.GREEN # support
|
||||
label = lvl.upper()
|
||||
print(f" {label:>6}: {color}{val:.5f}{Colors.RESET}")
|
||||
|
||||
|
||||
def print_event_calendar(reports: List[SignalReport]):
|
||||
"""Print upcoming economic events affecting watched pairs."""
|
||||
events_shown = set()
|
||||
has_events = False
|
||||
|
||||
for report in reports:
|
||||
if report.event_risk != "clear" and report.event_description not in events_shown:
|
||||
if not has_events:
|
||||
print(f"\n{Colors.YELLOW}{Colors.BOLD} 📅 ECONOMIC CALENDAR ALERTS{Colors.RESET}")
|
||||
has_events = True
|
||||
events_shown.add(report.event_description)
|
||||
risk_color = Colors.RED if report.event_risk == "danger" else Colors.YELLOW
|
||||
print(f" {risk_color}● {report.event_description}{Colors.RESET} → affects {report.display_name}")
|
||||
|
||||
if not has_events:
|
||||
print(f"\n{Colors.GRAY} 📅 No high-impact events in the near term{Colors.RESET}")
|
||||
|
||||
|
||||
def report_to_dict(report: SignalReport) -> dict:
|
||||
"""Convert a SignalReport to a JSON-serializable dict."""
|
||||
d = {
|
||||
"symbol": report.symbol,
|
||||
"display_name": report.display_name,
|
||||
"timestamp": report.timestamp,
|
||||
"current_price": report.current_price,
|
||||
"signal": report.final_signal.name,
|
||||
"score": round(report.final_score, 2),
|
||||
"confidence": round(report.final_confidence, 2),
|
||||
"quality": report.signal_quality,
|
||||
"action": report.action_recommendation,
|
||||
"market_regime": report.market_regime,
|
||||
"volatility_regime": report.volatility_regime,
|
||||
"mtf_agreement": report.mtf_agreement,
|
||||
"mtf_signals": {k: v.name for k, v in report.mtf_signals.items()},
|
||||
"event_risk": report.event_risk,
|
||||
"event_description": report.event_description,
|
||||
"news_sentiment": round(report.news_sentiment, 3),
|
||||
"bullish_reasons": report.bullish_reasons,
|
||||
"bearish_reasons": report.bearish_reasons,
|
||||
"warnings": report.warnings,
|
||||
}
|
||||
if report.trade_setup:
|
||||
ts = report.trade_setup
|
||||
d["trade_setup"] = {
|
||||
"direction": ts.direction,
|
||||
"entry": ts.entry_price,
|
||||
"stop_loss": ts.stop_loss,
|
||||
"take_profit_1": ts.take_profit_1,
|
||||
"take_profit_2": ts.take_profit_2,
|
||||
"risk_reward": ts.risk_reward,
|
||||
"risk_pips": round(ts.risk_pips, 1),
|
||||
"reward_pips": round(ts.reward_pips, 1),
|
||||
}
|
||||
if report.primary_analysis:
|
||||
d["indicators"] = {}
|
||||
for name, ind in report.primary_analysis.indicators.items():
|
||||
if not name.startswith("_"):
|
||||
d["indicators"][name] = {
|
||||
"signal": ind.signal.name,
|
||||
"confidence": round(ind.confidence, 1),
|
||||
"description": ind.description,
|
||||
}
|
||||
d["key_levels"] = {
|
||||
k: round(v, 5) for k, v in report.primary_analysis.key_levels.items()
|
||||
}
|
||||
return d
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════
|
||||
# MAIN
|
||||
# ══════════════════════════════════════════════════════════════════
|
||||
|
||||
def parse_args():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Forex Signal Intelligence Platform",
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
epilog="""
|
||||
Examples:
|
||||
python main.py Analyze all major pairs (H1)
|
||||
python main.py --pairs EURUSD GBPUSD Analyze specific pairs
|
||||
python main.py --timeframe H4 Use 4-hour as primary TF
|
||||
python main.py --all Include cross pairs
|
||||
python main.py --json Output as JSON
|
||||
python main.py --detail Show detailed analysis per pair
|
||||
python main.py --watch Continuous monitoring (5min refresh)
|
||||
""",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--pairs", nargs="+", default=None,
|
||||
help="Specific pairs to analyze (e.g., EURUSD GBPUSD)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--timeframe", "-tf", default="H1",
|
||||
choices=["M5", "M15", "M30", "H1", "H4", "D1"],
|
||||
help="Primary analysis timeframe (default: H1)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--all", action="store_true",
|
||||
help="Include cross pairs in analysis",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--json", action="store_true",
|
||||
help="Output results as JSON",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--detail", action="store_true",
|
||||
help="Show detailed analysis for each pair",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--top", type=int, default=None,
|
||||
help="Show only top N signals by strength",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--watch", action="store_true",
|
||||
help="Continuous monitoring mode (refreshes every 5 min)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--min-grade", default="F",
|
||||
choices=["A+", "A", "B", "C", "D", "F"],
|
||||
help="Minimum signal quality to display",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--verbose", "-v", action="store_true",
|
||||
help="Enable debug logging",
|
||||
)
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def symbol_from_name(name: str) -> str:
|
||||
"""Convert pair name like 'EURUSD' to Yahoo symbol 'EURUSD=X'."""
|
||||
name = name.upper().replace("/", "").replace("_", "")
|
||||
if not name.endswith("=X"):
|
||||
name += "=X"
|
||||
return name
|
||||
|
||||
|
||||
def run_analysis(args) -> List[SignalReport]:
|
||||
"""Run a single analysis cycle."""
|
||||
config = PlatformConfig()
|
||||
|
||||
# Configure timeframe
|
||||
tf_map = {
|
||||
"M5": Timeframe.M5, "M15": Timeframe.M15, "M30": Timeframe.M30,
|
||||
"H1": Timeframe.H1, "H4": Timeframe.H4, "D1": Timeframe.D1,
|
||||
}
|
||||
config.primary_timeframe = tf_map[args.timeframe]
|
||||
|
||||
# Configure confirmation timeframes based on primary
|
||||
tf_confirmations = {
|
||||
"M5": [Timeframe.M1, Timeframe.M15],
|
||||
"M15": [Timeframe.M5, Timeframe.H1],
|
||||
"M30": [Timeframe.M15, Timeframe.H1],
|
||||
"H1": [Timeframe.M15, Timeframe.H4],
|
||||
"H4": [Timeframe.H1, Timeframe.D1],
|
||||
"D1": [Timeframe.H4, Timeframe.W1],
|
||||
}
|
||||
config.confirmation_timeframes = tf_confirmations.get(
|
||||
args.timeframe, [Timeframe.M15, Timeframe.H4]
|
||||
)
|
||||
|
||||
# Configure pairs
|
||||
if args.pairs:
|
||||
config.watch_pairs = [symbol_from_name(p) for p in args.pairs]
|
||||
elif args.all:
|
||||
config.watch_pairs = MAJOR_PAIRS + CROSS_PAIRS
|
||||
else:
|
||||
config.watch_pairs = MAJOR_PAIRS
|
||||
|
||||
# Run analysis
|
||||
aggregator = SignalAggregator(config)
|
||||
reports = aggregator.analyze_all_pairs()
|
||||
|
||||
# Filter by grade
|
||||
grade_order = ["A+", "A", "B", "C", "D", "F"]
|
||||
min_idx = grade_order.index(args.min_grade) if args.min_grade in grade_order else len(grade_order) - 1
|
||||
reports = [r for r in reports if grade_order.index(r.signal_quality) <= min_idx]
|
||||
|
||||
# Top N
|
||||
if args.top:
|
||||
reports = reports[:args.top]
|
||||
|
||||
return reports
|
||||
|
||||
|
||||
def main():
|
||||
args = parse_args()
|
||||
|
||||
# Setup logging
|
||||
log_level = logging.DEBUG if args.verbose else logging.WARNING
|
||||
logging.basicConfig(
|
||||
level=log_level,
|
||||
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
|
||||
datefmt="%H:%M:%S",
|
||||
)
|
||||
|
||||
if args.watch:
|
||||
# Continuous monitoring mode
|
||||
print(f"{Colors.BOLD}Starting continuous monitoring mode (Ctrl+C to stop)...{Colors.RESET}")
|
||||
while True:
|
||||
try:
|
||||
reports = run_analysis(args)
|
||||
if args.json:
|
||||
output = [report_to_dict(r) for r in reports]
|
||||
print(json.dumps(output, indent=2))
|
||||
else:
|
||||
print("\033[2J\033[H") # clear screen
|
||||
print_header()
|
||||
print_summary_table(reports)
|
||||
print_event_calendar(reports)
|
||||
if args.detail:
|
||||
for r in reports:
|
||||
print_detailed_report(r)
|
||||
print(f"\n{Colors.GRAY} Next refresh in 5 minutes...{Colors.RESET}")
|
||||
|
||||
time.sleep(300)
|
||||
except KeyboardInterrupt:
|
||||
print(f"\n{Colors.YELLOW}Monitoring stopped.{Colors.RESET}")
|
||||
break
|
||||
else:
|
||||
# Single run
|
||||
print(f"{Colors.GRAY} Fetching market data and running analysis...{Colors.RESET}\n")
|
||||
reports = run_analysis(args)
|
||||
|
||||
if args.json:
|
||||
output = [report_to_dict(r) for r in reports]
|
||||
print(json.dumps(output, indent=2))
|
||||
else:
|
||||
print_header()
|
||||
if reports:
|
||||
print_summary_table(reports)
|
||||
print_event_calendar(reports)
|
||||
|
||||
if args.detail:
|
||||
for r in reports:
|
||||
print_detailed_report(r)
|
||||
else:
|
||||
# Show detail for top signals only
|
||||
actionable = [r for r in reports if r.signal_quality in ("A+", "A", "B")]
|
||||
if actionable:
|
||||
print(f"\n{Colors.BOLD}{Colors.WHITE} ═══ ACTIONABLE SIGNALS (Grade B or above) ═══{Colors.RESET}")
|
||||
for r in actionable:
|
||||
print_detailed_report(r)
|
||||
else:
|
||||
print(f"\n{Colors.GRAY} No high-grade signals detected. "
|
||||
f"Use --detail for full breakdown or --min-grade C to see more.{Colors.RESET}")
|
||||
else:
|
||||
print(f"{Colors.YELLOW} No data available. Check your internet connection.{Colors.RESET}")
|
||||
|
||||
print(f"\n{Colors.CYAN}{'═' * 80}{Colors.RESET}")
|
||||
print(f"{Colors.GRAY} Disclaimer: This tool is for educational/research purposes only.{Colors.RESET}")
|
||||
print(f"{Colors.GRAY} Past performance ≠ future results. Always use proper risk management.{Colors.RESET}")
|
||||
print(f"{Colors.CYAN}{'═' * 80}{Colors.RESET}\n")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
ForexBot2 — USD/JPY Signal Intelligence (single-pair)
|
||||
=======================================================
|
||||
Usage:
|
||||
python main.py # Live signal on H1
|
||||
python main.py --timeframe H4 --detail # Detailed H4 signal
|
||||
python main.py --json # JSON output
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import sys
|
||||
from datetime import datetime, timezone
|
||||
from typing import Dict, List
|
||||
|
||||
# Force UTF-8 output on Windows so box-drawing chars render
|
||||
if hasattr(sys.stdout, "reconfigure"):
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
if hasattr(sys.stderr, "reconfigure"):
|
||||
sys.stderr.reconfigure(encoding="utf-8")
|
||||
|
||||
from config import PlatformConfig, Timeframe, SignalStrength, USDJPY, DISPLAY
|
||||
from signal_aggregator import SignalAggregator, SignalReport
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════
|
||||
# TERMINAL FORMATTING
|
||||
# ══════════════════════════════════════════════════════════════════
|
||||
|
||||
class Colors:
|
||||
RESET = "\033[0m"
|
||||
BOLD = "\033[1m"
|
||||
DIM = "\033[2m"
|
||||
UNDERLINE = "\033[4m"
|
||||
RED = "\033[91m"
|
||||
GREEN = "\033[92m"
|
||||
YELLOW = "\033[93m"
|
||||
BLUE = "\033[94m"
|
||||
MAGENTA = "\033[95m"
|
||||
CYAN = "\033[96m"
|
||||
WHITE = "\033[97m"
|
||||
GRAY = "\033[90m"
|
||||
|
||||
|
||||
def signal_color(signal: SignalStrength) -> str:
|
||||
return {
|
||||
SignalStrength.STRONG_BUY: Colors.GREEN + Colors.BOLD,
|
||||
SignalStrength.BUY: Colors.GREEN,
|
||||
SignalStrength.NEUTRAL: Colors.GRAY,
|
||||
SignalStrength.SELL: Colors.RED,
|
||||
SignalStrength.STRONG_SELL: Colors.RED + Colors.BOLD,
|
||||
}.get(signal, Colors.RESET)
|
||||
|
||||
|
||||
def quality_color(q: str) -> str:
|
||||
return {
|
||||
"A+": Colors.GREEN + Colors.BOLD,
|
||||
"A": Colors.GREEN,
|
||||
"B": Colors.CYAN,
|
||||
"C": Colors.YELLOW,
|
||||
"D": Colors.GRAY,
|
||||
"F": Colors.DIM,
|
||||
}.get(q, Colors.RESET)
|
||||
|
||||
|
||||
def print_header(title: str = "USD/JPY SIGNAL INTELLIGENCE"):
|
||||
now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
|
||||
print(f"\n{Colors.CYAN}{'═' * 80}{Colors.RESET}")
|
||||
print(f"{Colors.BOLD}{Colors.CYAN} {title}{Colors.RESET}")
|
||||
print(f"{Colors.GRAY} Time: {now}{Colors.RESET}")
|
||||
print(f"{Colors.CYAN}{'═' * 80}{Colors.RESET}\n")
|
||||
|
||||
|
||||
# ── Live signal renderer ───────────────────────────────────────────
|
||||
|
||||
_INDICATOR_PREFIXES = (
|
||||
"EMA Trend", "RSI", "Bollinger Bands", "Divergence",
|
||||
"Candlestick", "ADX", "ATR", "News", "Regime",
|
||||
)
|
||||
|
||||
|
||||
def _compact_reason(reason: str) -> str:
|
||||
"""Shorten a verbose reason string for the compact view."""
|
||||
s = reason
|
||||
if s.startswith("STRONG: "):
|
||||
s = s[8:]
|
||||
# Strip the leading "<Indicator>: " prefix — it's always an indicator name
|
||||
for prefix in _INDICATOR_PREFIXES:
|
||||
if s.startswith(prefix + ": "):
|
||||
s = s[len(prefix) + 2:]
|
||||
break
|
||||
# Drop trailing detail after first ' | '
|
||||
if " | " in s:
|
||||
s = s.split(" | ", 1)[0]
|
||||
return s.strip()
|
||||
|
||||
|
||||
def print_signal_report(report: SignalReport, detail: bool = False):
|
||||
sc = signal_color(report.final_signal)
|
||||
qc = quality_color(report.signal_quality)
|
||||
sig_name = report.final_signal.name.replace("_", " ")
|
||||
|
||||
# ── 1. DECISION ────────────────────────────────────────────────
|
||||
mtf_tag = (f"{Colors.GREEN}MTF✓{Colors.RESET}" if report.mtf_agreement
|
||||
else f"{Colors.YELLOW}MTF✗{Colors.RESET}")
|
||||
print(f" {sc}▶ {sig_name}{Colors.RESET} "
|
||||
f"{qc}{report.signal_quality}{Colors.RESET} · "
|
||||
f"{sc}{report.final_score:+.1f}{Colors.RESET} · "
|
||||
f"{report.final_confidence:.0f}% · {mtf_tag}")
|
||||
print(f" {Colors.GRAY}{report.action_recommendation}{Colors.RESET}")
|
||||
|
||||
# ── 2. TRADE SETUP (if signal is actionable) ───────────────────
|
||||
if report.trade_setup:
|
||||
ts = report.trade_setup
|
||||
dc = Colors.GREEN if ts.direction == "BUY" else Colors.RED
|
||||
print(f"\n {Colors.BOLD}Setup{Colors.RESET} "
|
||||
f"{dc}{ts.direction}{Colors.RESET} @ {Colors.BOLD}{ts.entry_price:.3f}{Colors.RESET} "
|
||||
f"→ SL {Colors.RED}{ts.stop_loss:.3f}{Colors.RESET} "
|
||||
f"({ts.risk_pips:.1f}p) "
|
||||
f"→ TP {Colors.GREEN}{ts.take_profit_1:.3f}{Colors.RESET} "
|
||||
f"({ts.reward_pips:.1f}p) "
|
||||
f"RR 1:{ts.risk_reward:.1f}")
|
||||
|
||||
# ── 3. CONTEXT (price · regime · vol · MTF breakdown) ──────────
|
||||
print(f"\n {Colors.WHITE}{report.display_name}{Colors.RESET} "
|
||||
f"{Colors.BOLD}{report.current_price:.3f}{Colors.RESET} · "
|
||||
f"{Colors.CYAN}{report.market_regime}{Colors.RESET} · "
|
||||
f"vol {report.volatility_regime}")
|
||||
|
||||
if report.mtf_signals:
|
||||
parts = []
|
||||
for tf, sig in report.mtf_signals.items():
|
||||
tf_sc = signal_color(sig)
|
||||
sc_val = report.mtf_scores.get(tf, 0)
|
||||
parts.append(f"{tf} {tf_sc}{sig.name.replace('_',' ')}{Colors.RESET} {sc_val:+.1f}")
|
||||
print(f" {Colors.GRAY}MTF{Colors.RESET} " + " · ".join(parts))
|
||||
|
||||
# ── 4. WHY — top 3 each side, compact ──────────────────────────
|
||||
bulls = [_compact_reason(r) for r in report.bullish_reasons[:3]]
|
||||
bears = [_compact_reason(r) for r in report.bearish_reasons[:3]]
|
||||
if bulls or bears:
|
||||
print()
|
||||
rows = max(len(bulls), len(bears))
|
||||
for i in range(rows):
|
||||
left = f"{Colors.GREEN}+{Colors.RESET} {bulls[i]}" if i < len(bulls) else ""
|
||||
right = f"{Colors.RED}-{Colors.RESET} {bears[i]}" if i < len(bears) else ""
|
||||
print(f" {left:<60} {right}")
|
||||
|
||||
# ── 5. WARNINGS / NEWS / EVENTS ────────────────────────────────
|
||||
if report.warnings:
|
||||
for w in report.warnings:
|
||||
print(f" {Colors.YELLOW}⚠{Colors.RESET} {w}")
|
||||
if report.event_description and report.event_risk != "clear":
|
||||
print(f" {Colors.YELLOW}📅{Colors.RESET} {report.event_description}")
|
||||
if report.news_description and report.news_description != "Neutral news sentiment":
|
||||
print(f" {Colors.MAGENTA}📰{Colors.RESET} {report.news_description}")
|
||||
|
||||
# ── 6. DETAIL (only with --detail) ─────────────────────────────
|
||||
if detail and report.primary_analysis:
|
||||
print(f"\n {Colors.BOLD}Indicators ({report.primary_analysis.timeframe}){Colors.RESET}")
|
||||
for name, ind in report.primary_analysis.indicators.items():
|
||||
if name.startswith("_") or ind.weight == 0:
|
||||
continue
|
||||
isc = signal_color(ind.signal)
|
||||
print(f" {ind.name:<16} {isc}{ind.signal.name.replace('_',' '):<11}{Colors.RESET} "
|
||||
f"{ind.confidence:>3.0f}% {Colors.GRAY}│ {ind.description}{Colors.RESET}")
|
||||
|
||||
levels = report.primary_analysis.key_levels
|
||||
if levels:
|
||||
swing_keys = sorted(
|
||||
[k for k in levels if k.startswith("swing_")],
|
||||
key=lambda k: levels[k], reverse=True,
|
||||
)
|
||||
if swing_keys:
|
||||
print(f"\n {Colors.BOLD}Structure Levels{Colors.RESET}")
|
||||
for k in swing_keys:
|
||||
val = levels[k]
|
||||
color = Colors.RED if val > report.current_price else Colors.GREEN
|
||||
label = k.replace("_", " ").title()
|
||||
print(f" {label:>20} {color}{val:.3f}{Colors.RESET}")
|
||||
|
||||
|
||||
def report_to_dict(report: SignalReport) -> dict:
|
||||
d = {
|
||||
"symbol": report.symbol,
|
||||
"display_name": report.display_name,
|
||||
"timestamp": report.timestamp,
|
||||
"current_price": report.current_price,
|
||||
"signal": report.final_signal.name,
|
||||
"score": round(report.final_score, 2),
|
||||
"confidence": round(report.final_confidence, 2),
|
||||
"quality": report.signal_quality,
|
||||
"action": report.action_recommendation,
|
||||
"market_regime": report.market_regime,
|
||||
"volatility_regime": report.volatility_regime,
|
||||
"mtf_agreement": report.mtf_agreement,
|
||||
"mtf_signals": {k: v.name for k, v in report.mtf_signals.items()},
|
||||
"event_risk": report.event_risk,
|
||||
"event_description": report.event_description,
|
||||
"news_sentiment": round(report.news_sentiment, 3),
|
||||
"bullish_reasons": report.bullish_reasons,
|
||||
"bearish_reasons": report.bearish_reasons,
|
||||
"warnings": report.warnings,
|
||||
}
|
||||
if report.trade_setup:
|
||||
ts = report.trade_setup
|
||||
d["trade_setup"] = {
|
||||
"direction": ts.direction,
|
||||
"entry": ts.entry_price,
|
||||
"stop_loss": ts.stop_loss,
|
||||
"take_profit_1": ts.take_profit_1,
|
||||
"take_profit_2": ts.take_profit_2,
|
||||
"risk_reward": ts.risk_reward,
|
||||
"risk_pips": round(ts.risk_pips, 1),
|
||||
"reward_pips": round(ts.reward_pips, 1),
|
||||
}
|
||||
if report.primary_analysis:
|
||||
d["indicators"] = {
|
||||
name: {
|
||||
"signal": ind.signal.name,
|
||||
"confidence": round(ind.confidence, 1),
|
||||
"description": ind.description,
|
||||
}
|
||||
for name, ind in report.primary_analysis.indicators.items()
|
||||
if not name.startswith("_")
|
||||
}
|
||||
d["key_levels"] = {
|
||||
k: round(v, 5) for k, v in report.primary_analysis.key_levels.items()
|
||||
}
|
||||
return d
|
||||
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════
|
||||
# CLI
|
||||
# ══════════════════════════════════════════════════════════════════
|
||||
|
||||
def parse_args():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="ForexBot2 — USD/JPY Signal Intelligence",
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
epilog="""
|
||||
Examples:
|
||||
python main.py Live signal (H1, summary)
|
||||
python main.py --detail Live signal with full breakdown
|
||||
python main.py --timeframe H4 --detail H4 timeframe
|
||||
python main.py --json JSON output
|
||||
""",
|
||||
)
|
||||
parser.add_argument("--timeframe", "-tf", default="H1",
|
||||
choices=["M5", "M15", "M30", "H1", "H4", "D1"],
|
||||
help="Primary analysis timeframe (default: H1)")
|
||||
parser.add_argument("--detail", action="store_true",
|
||||
help="Show full indicator breakdown")
|
||||
parser.add_argument("--json", action="store_true",
|
||||
help="Output as JSON")
|
||||
parser.add_argument("--verbose", "-v", action="store_true",
|
||||
help="Debug logging")
|
||||
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def build_config(args) -> PlatformConfig:
|
||||
config = PlatformConfig()
|
||||
|
||||
tf_map = {
|
||||
"M5": Timeframe.M5, "M15": Timeframe.M15, "M30": Timeframe.M30,
|
||||
"H1": Timeframe.H1, "H4": Timeframe.H4, "D1": Timeframe.D1,
|
||||
}
|
||||
config.primary_timeframe = tf_map[args.timeframe]
|
||||
|
||||
tf_confirmations = {
|
||||
"M5": [Timeframe.M1, Timeframe.M15],
|
||||
"M15": [Timeframe.M5, Timeframe.H1],
|
||||
"M30": [Timeframe.M15, Timeframe.H1],
|
||||
"H1": [Timeframe.M15, Timeframe.H4],
|
||||
"H4": [Timeframe.H1, Timeframe.D1],
|
||||
"D1": [Timeframe.H4, Timeframe.W1],
|
||||
}
|
||||
config.confirmation_timeframes = tf_confirmations.get(
|
||||
args.timeframe, [Timeframe.M15, Timeframe.H4]
|
||||
)
|
||||
|
||||
return config
|
||||
|
||||
|
||||
def run_live(args, config: PlatformConfig):
|
||||
print(f"{Colors.GRAY} Fetching market data and running analysis...{Colors.RESET}\n")
|
||||
aggregator = SignalAggregator(config)
|
||||
report = aggregator.analyze_pair()
|
||||
|
||||
if args.json:
|
||||
print(json.dumps(report_to_dict(report), indent=2))
|
||||
return
|
||||
|
||||
print_header("USD/JPY SIGNAL INTELLIGENCE")
|
||||
print_signal_report(report, detail=args.detail)
|
||||
print(f"\n{Colors.CYAN}{'═' * 80}{Colors.RESET}")
|
||||
print(f"{Colors.GRAY} Disclaimer: For educational/research purposes only.{Colors.RESET}")
|
||||
print(f"{Colors.CYAN}{'═' * 80}{Colors.RESET}\n")
|
||||
|
||||
|
||||
def main():
|
||||
args = parse_args()
|
||||
|
||||
log_level = logging.DEBUG if args.verbose else logging.WARNING
|
||||
logging.basicConfig(
|
||||
level=log_level,
|
||||
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
|
||||
datefmt="%H:%M:%S",
|
||||
)
|
||||
|
||||
config = build_config(args)
|
||||
run_live(args, config)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
Regular → Executable
+18
-17
@@ -104,6 +104,7 @@ class NewsEngine:
|
||||
"AUD": ["aussie", "rba", "australian", "australia"],
|
||||
"CAD": ["loonie", "boc", "canadian", "canada"],
|
||||
"NZD": ["kiwi", "rbnz", "new zealand"],
|
||||
"XAU": ["gold", "xau", "precious metal", "safe haven", "bullion"],
|
||||
}
|
||||
|
||||
# High-impact event types (these move markets significantly)
|
||||
@@ -187,15 +188,21 @@ class NewsEngine:
|
||||
|
||||
return context
|
||||
|
||||
@staticmethod
|
||||
def _parse_pair(pair_symbol: str) -> Tuple[str, str]:
|
||||
if "/" in pair_symbol:
|
||||
parts = pair_symbol.split("/")
|
||||
return parts[0], parts[1]
|
||||
clean = pair_symbol.replace("=X", "")
|
||||
return clean[:3], clean[3:]
|
||||
|
||||
def get_event_risk_level(self, pair_symbol: str, context: FundamentalContext) -> Tuple[str, str]:
|
||||
"""
|
||||
Get event risk level for a specific pair.
|
||||
Returns (risk_level, description).
|
||||
risk_level: "clear", "caution", "danger"
|
||||
"""
|
||||
clean = pair_symbol.replace("=X", "")
|
||||
base = clean[:3]
|
||||
quote = clean[3:]
|
||||
base, quote = self._parse_pair(pair_symbol)
|
||||
|
||||
# Check upcoming high-impact events
|
||||
for event in context.events_upcoming_1h:
|
||||
@@ -222,9 +229,7 @@ class NewsEngine:
|
||||
Returns (score, description) where score is -1 to +1.
|
||||
Positive = bullish for the pair, negative = bearish.
|
||||
"""
|
||||
clean = pair_symbol.replace("=X", "")
|
||||
base = clean[:3]
|
||||
quote = clean[3:]
|
||||
base, quote = self._parse_pair(pair_symbol)
|
||||
|
||||
base_sent = context.news_sentiment.get(base, 0.0)
|
||||
quote_sent = context.news_sentiment.get(quote, 0.0)
|
||||
@@ -413,15 +418,11 @@ class NewsEngine:
|
||||
|
||||
@staticmethod
|
||||
def _get_affected_pairs(currency: str) -> List[str]:
|
||||
"""Get all major pairs affected by a currency event."""
|
||||
pairs = {
|
||||
"USD": ["EURUSD=X", "GBPUSD=X", "USDJPY=X", "USDCHF=X", "AUDUSD=X", "USDCAD=X", "NZDUSD=X"],
|
||||
"EUR": ["EURUSD=X", "EURGBP=X", "EURJPY=X", "EURCHF=X"],
|
||||
"GBP": ["GBPUSD=X", "EURGBP=X", "GBPJPY=X"],
|
||||
"JPY": ["USDJPY=X", "EURJPY=X", "GBPJPY=X", "AUDJPY=X", "CADJPY=X"],
|
||||
"CHF": ["USDCHF=X", "EURCHF=X"],
|
||||
"AUD": ["AUDUSD=X", "AUDJPY=X"],
|
||||
"CAD": ["USDCAD=X", "CADJPY=X"],
|
||||
"NZD": ["NZDUSD=X"],
|
||||
_MAP = {
|
||||
"USD": ["EURUSD=X", "USDJPY=X", "GBPUSD=X", "XAU/USD"],
|
||||
"EUR": ["EURUSD=X"],
|
||||
"JPY": ["USDJPY=X"],
|
||||
"GBP": ["GBPUSD=X"],
|
||||
"XAU": ["XAU/USD"],
|
||||
}
|
||||
return pairs.get(currency, [])
|
||||
return _MAP.get(currency, [])
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
numpy>=1.24
|
||||
pandas>=2.0
|
||||
requests>=2.28
|
||||
twelvedata>=1.2.0
|
||||
python-telegram-bot>=20.0
|
||||
websockets>=12.0
|
||||
@@ -1 +0,0 @@
|
||||
pip install pandas numpy requests python-dateutil -q
|
||||
Regular → Executable
+318
-165
@@ -1,29 +1,19 @@
|
||||
"""
|
||||
Forex Signal Intelligence Platform - Signal Aggregator
|
||||
========================================================
|
||||
Combines technical analysis across multiple timeframes with
|
||||
fundamental/news context to produce final actionable signals.
|
||||
|
||||
This is the brain — it decides what's actually worth paying attention to.
|
||||
|
||||
Key principles:
|
||||
1. Multi-timeframe agreement = higher confidence
|
||||
2. High-impact news overrides technicals
|
||||
3. Divergences between timeframes = caution
|
||||
4. No signal is better than a bad signal
|
||||
ForexBot2 — Signal Aggregator
|
||||
==============================
|
||||
Combines multi-timeframe technical analysis with optional news context
|
||||
into a graded actionable signal.
|
||||
"""
|
||||
|
||||
import logging
|
||||
import os
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from typing import Dict, List, Optional
|
||||
|
||||
import pandas as pd
|
||||
|
||||
from config import (
|
||||
PlatformConfig, SignalStrength, Timeframe,
|
||||
SYMBOL_DISPLAY,
|
||||
)
|
||||
from config import PlatformConfig, SignalStrength, Timeframe
|
||||
from data_provider import ForexDataProvider
|
||||
from engine import TechnicalEngine, TechnicalAnalysis
|
||||
from news_engine import NewsEngine, FundamentalContext
|
||||
@@ -33,10 +23,9 @@ logger = logging.getLogger(__name__)
|
||||
|
||||
@dataclass
|
||||
class TradeSetup:
|
||||
"""A complete trade setup recommendation."""
|
||||
pair: str
|
||||
display_name: str
|
||||
direction: str # "BUY" or "SELL"
|
||||
direction: str # "BUY" / "SELL"
|
||||
entry_price: float
|
||||
stop_loss: float
|
||||
take_profit_1: float
|
||||
@@ -49,47 +38,38 @@ class TradeSetup:
|
||||
|
||||
@dataclass
|
||||
class SignalReport:
|
||||
"""Complete signal report for a single pair."""
|
||||
symbol: str
|
||||
display_name: str
|
||||
timestamp: str
|
||||
|
||||
# Composite signals
|
||||
primary_signal: SignalStrength = SignalStrength.NEUTRAL
|
||||
primary_score: float = 0.0
|
||||
primary_confidence: float = 0.0
|
||||
|
||||
# Multi-timeframe agreement
|
||||
mtf_agreement: bool = False
|
||||
mtf_signals: Dict[str, SignalStrength] = field(default_factory=dict)
|
||||
mtf_scores: Dict[str, float] = field(default_factory=dict)
|
||||
|
||||
# Technical details
|
||||
primary_analysis: Optional[TechnicalAnalysis] = None
|
||||
confirmation_analyses: List[TechnicalAnalysis] = field(default_factory=list)
|
||||
|
||||
# Fundamental context
|
||||
event_risk: str = "clear"
|
||||
event_description: str = ""
|
||||
news_sentiment: float = 0.0
|
||||
news_description: str = ""
|
||||
|
||||
# Final verdict
|
||||
final_signal: SignalStrength = SignalStrength.NEUTRAL
|
||||
final_score: float = 0.0
|
||||
final_confidence: float = 0.0
|
||||
action_recommendation: str = ""
|
||||
signal_quality: str = "" # "A+", "A", "B", "C", "D", "F"
|
||||
signal_quality: str = "" # A+, A, B, C, D, F
|
||||
|
||||
# Trade setup (only for actionable signals)
|
||||
trade_setup: Optional[TradeSetup] = None
|
||||
|
||||
# Key reasons
|
||||
bullish_reasons: List[str] = field(default_factory=list)
|
||||
bearish_reasons: List[str] = field(default_factory=list)
|
||||
warnings: List[str] = field(default_factory=list)
|
||||
|
||||
# Current price info
|
||||
current_price: float = 0.0
|
||||
spread_estimate: float = 0.0
|
||||
market_regime: str = ""
|
||||
@@ -97,54 +77,162 @@ class SignalReport:
|
||||
|
||||
|
||||
class SignalAggregator:
|
||||
"""
|
||||
Master signal aggregator.
|
||||
|
||||
Orchestrates data fetching, technical analysis across timeframes,
|
||||
fundamental analysis, and produces final graded signals.
|
||||
"""
|
||||
"""Master aggregator for live signal analysis."""
|
||||
|
||||
def __init__(self, config: PlatformConfig):
|
||||
self.config = config
|
||||
self.data_provider = ForexDataProvider(config)
|
||||
self.tech_engine = TechnicalEngine(config.technical)
|
||||
self.news_engine = NewsEngine(config.news)
|
||||
self._news_engine: Optional[NewsEngine] = None # lazy
|
||||
|
||||
def analyze_all_pairs(self) -> List[SignalReport]:
|
||||
"""
|
||||
Analyze all watched pairs and return sorted signal reports.
|
||||
Returns reports sorted by signal quality (best first).
|
||||
"""
|
||||
reports = []
|
||||
context = self.news_engine.get_fundamental_context()
|
||||
def _get_news_engine(self) -> NewsEngine:
|
||||
if self._news_engine is None:
|
||||
self._news_engine = NewsEngine(self.config.news)
|
||||
return self._news_engine
|
||||
|
||||
# Batch-prefetch all pairs × all needed timeframes (3 API calls instead of 21)
|
||||
all_timeframes = (
|
||||
[self.config.primary_timeframe] + self.config.confirmation_timeframes
|
||||
)
|
||||
self.data_provider.prefetch_batch(self.config.watch_pairs, all_timeframes)
|
||||
|
||||
for symbol in self.config.watch_pairs:
|
||||
try:
|
||||
report = self.analyze_pair(symbol, context)
|
||||
reports.append(report)
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to analyze {symbol}: {e}")
|
||||
continue
|
||||
|
||||
# Sort by absolute score (strongest signals first)
|
||||
reports.sort(key=lambda r: abs(r.final_score), reverse=True)
|
||||
return reports
|
||||
# ── Public: live mode entry point ──────────────────────────────
|
||||
|
||||
def analyze_pair(
|
||||
self,
|
||||
symbol: str,
|
||||
symbol: Optional[str] = None,
|
||||
context: Optional[FundamentalContext] = None,
|
||||
) -> SignalReport:
|
||||
"""Complete analysis of a single pair across all layers."""
|
||||
if context is None:
|
||||
context = self.news_engine.get_fundamental_context()
|
||||
"""Live-mode entry: fetch all needed timeframes then delegate."""
|
||||
if symbol is None:
|
||||
symbol = self.config.symbol
|
||||
|
||||
timeframes = [self.config.primary_timeframe] + list(
|
||||
self.config.confirmation_timeframes
|
||||
)
|
||||
|
||||
bt = self.config.backtest
|
||||
if bt.regime_filter and bt.regime_filter_timeframe not in timeframes:
|
||||
timeframes.append(bt.regime_filter_timeframe)
|
||||
|
||||
dfs: Dict[Timeframe, pd.DataFrame] = {}
|
||||
for tf in timeframes:
|
||||
try:
|
||||
dfs[tf] = self.data_provider.fetch_ohlcv(symbol, tf)
|
||||
except Exception as e:
|
||||
logger.warning(f"Fetch failed for {symbol} {tf.value}: {e}")
|
||||
|
||||
report = self.analyze_from_dataframes(
|
||||
symbol=symbol,
|
||||
dfs=dfs,
|
||||
context=context,
|
||||
use_news=True,
|
||||
)
|
||||
|
||||
if bt.regime_filter:
|
||||
self._apply_regime_filter_live(report, dfs)
|
||||
|
||||
if bt.session_filter:
|
||||
self._apply_session_filter_live(report)
|
||||
|
||||
return report
|
||||
|
||||
def _apply_session_filter_live(self, report: SignalReport) -> None:
|
||||
"""Skip signals outside the configured UTC trading window."""
|
||||
bt = self.config.backtest
|
||||
now_h = datetime.now(timezone.utc).hour
|
||||
if not (bt.session_start_hour <= now_h < bt.session_end_hour):
|
||||
report.warnings.append(
|
||||
f"SESSION FILTER: {now_h:02}:00 UTC outside "
|
||||
f"{bt.session_start_hour:02}:00-{bt.session_end_hour:02}:00 — skipping"
|
||||
)
|
||||
report.final_signal = SignalStrength.NEUTRAL
|
||||
report.signal_quality = "F"
|
||||
report.action_recommendation = (
|
||||
f"NO TRADE — Outside session "
|
||||
f"({bt.session_start_hour:02}-{bt.session_end_hour:02} UTC; now {now_h:02})"
|
||||
)
|
||||
report.trade_setup = None
|
||||
else:
|
||||
report.warnings.append(
|
||||
f"Session: {now_h:02}:00 UTC inside trading window "
|
||||
f"{bt.session_start_hour:02}-{bt.session_end_hour:02}"
|
||||
)
|
||||
|
||||
def _apply_regime_filter_live(
|
||||
self, report: SignalReport, dfs: Dict[Timeframe, pd.DataFrame]
|
||||
) -> None:
|
||||
"""If higher-TF ADX is below threshold, downgrade signal to NEUTRAL."""
|
||||
bt = self.config.backtest
|
||||
regime_tf = bt.regime_filter_timeframe
|
||||
df = dfs.get(regime_tf)
|
||||
if df is None or df.empty:
|
||||
report.warnings.append(
|
||||
f"Regime filter requested but {regime_tf.value} data unavailable"
|
||||
)
|
||||
return
|
||||
|
||||
adx_value = self._latest_adx(df, self.config.technical.adx_period)
|
||||
if adx_value is None:
|
||||
report.warnings.append(
|
||||
f"Regime filter: ADX could not be computed on {regime_tf.value}"
|
||||
)
|
||||
return
|
||||
|
||||
if adx_value < bt.regime_filter_min_adx:
|
||||
report.warnings.append(
|
||||
f"REGIME FILTER: {regime_tf.value} ADX={adx_value:.1f} < "
|
||||
f"{bt.regime_filter_min_adx:.0f} — market choppy, skipping signal"
|
||||
)
|
||||
report.final_signal = SignalStrength.NEUTRAL
|
||||
report.signal_quality = "F"
|
||||
report.action_recommendation = (
|
||||
f"NO TRADE — Regime filter (ADX {adx_value:.1f} on {regime_tf.value})"
|
||||
)
|
||||
report.trade_setup = None
|
||||
else:
|
||||
report.bullish_reasons.append(
|
||||
f"Regime: {regime_tf.value} ADX={adx_value:.1f} confirms trending market"
|
||||
) if report.final_score > 0 else report.bearish_reasons.append(
|
||||
f"Regime: {regime_tf.value} ADX={adx_value:.1f} confirms trending market"
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _latest_adx(df: pd.DataFrame, period: int = 14) -> Optional[float]:
|
||||
"""Wilder ADX on a fresh df; returns the last finite value or None."""
|
||||
if df is None or len(df) < period * 3:
|
||||
return None
|
||||
high, low, close = df["High"], df["Low"], df["Close"]
|
||||
tr = pd.concat([
|
||||
high - low,
|
||||
(high - close.shift()).abs(),
|
||||
(low - close.shift()).abs(),
|
||||
], axis=1).max(axis=1)
|
||||
plus_dm = high.diff()
|
||||
minus_dm = -low.diff()
|
||||
plus_dm = plus_dm.where((plus_dm > minus_dm) & (plus_dm > 0), 0.0)
|
||||
minus_dm = minus_dm.where((minus_dm > plus_dm) & (minus_dm > 0), 0.0)
|
||||
atr_s = tr.ewm(alpha=1/period, min_periods=period).mean()
|
||||
plus_di = 100 * (plus_dm.ewm(alpha=1/period, min_periods=period).mean() / atr_s)
|
||||
minus_di = 100 * (minus_dm.ewm(alpha=1/period, min_periods=period).mean() / atr_s)
|
||||
denom = (plus_di + minus_di).replace(0, float("nan"))
|
||||
dx = 100 * (plus_di - minus_di).abs() / denom
|
||||
adx = dx.ewm(alpha=1/period, min_periods=period).mean().dropna()
|
||||
if adx.empty:
|
||||
return None
|
||||
return float(adx.iloc[-1])
|
||||
|
||||
# ── Public: bar-replayable entry point ─────────────────────────
|
||||
|
||||
def analyze_from_dataframes(
|
||||
self,
|
||||
symbol: str,
|
||||
dfs: Dict[Timeframe, pd.DataFrame],
|
||||
context: Optional[FundamentalContext] = None,
|
||||
use_news: bool = True,
|
||||
) -> SignalReport:
|
||||
"""
|
||||
Run the full analysis pipeline on already-fetched dataframes.
|
||||
|
||||
`dfs` must include the primary timeframe and ideally the
|
||||
confirmation timeframes. Each df is treated as the visible history
|
||||
at decision time — the backtester is responsible for slicing so
|
||||
no future bars leak in.
|
||||
"""
|
||||
pair_info = self.data_provider.get_pair_info(symbol)
|
||||
display = pair_info["display"]
|
||||
pip_value = pair_info["pip_value"]
|
||||
@@ -155,33 +243,33 @@ class SignalAggregator:
|
||||
timestamp=str(datetime.now(timezone.utc)),
|
||||
)
|
||||
|
||||
# ── 1. Primary Timeframe Analysis ──────────────────────────
|
||||
try:
|
||||
primary_df = self.data_provider.fetch_ohlcv(
|
||||
symbol, self.config.primary_timeframe
|
||||
)
|
||||
primary_analysis = self.tech_engine.analyze(
|
||||
primary_df, symbol, self.config.primary_timeframe.value
|
||||
)
|
||||
report.primary_analysis = primary_analysis
|
||||
report.primary_signal = primary_analysis.composite_signal
|
||||
report.primary_score = primary_analysis.composite_score
|
||||
report.primary_confidence = primary_analysis.confidence
|
||||
report.market_regime = primary_analysis.market_regime
|
||||
report.volatility_regime = primary_analysis.volatility_regime
|
||||
report.current_price = float(primary_df["Close"].iloc[-1])
|
||||
report.mtf_signals[self.config.primary_timeframe.value] = primary_analysis.composite_signal
|
||||
report.mtf_scores[self.config.primary_timeframe.value] = primary_analysis.composite_score
|
||||
except Exception as e:
|
||||
logger.error(f"Primary analysis failed for {symbol}: {e}")
|
||||
report.warnings.append(f"Primary timeframe data unavailable: {e}")
|
||||
# ── 1. Primary timeframe ───────────────────────────────────
|
||||
primary_df = dfs.get(self.config.primary_timeframe)
|
||||
if primary_df is None or primary_df.empty:
|
||||
report.warnings.append("Primary timeframe data unavailable")
|
||||
report.signal_quality = "F"
|
||||
return report
|
||||
|
||||
# ── 2. Confirmation Timeframe Analyses ─────────────────────
|
||||
primary_analysis = self.tech_engine.analyze(
|
||||
primary_df, symbol, self.config.primary_timeframe.value
|
||||
)
|
||||
report.primary_analysis = primary_analysis
|
||||
report.primary_signal = primary_analysis.composite_signal
|
||||
report.primary_score = primary_analysis.composite_score
|
||||
report.primary_confidence = primary_analysis.confidence
|
||||
report.market_regime = primary_analysis.market_regime
|
||||
report.volatility_regime = primary_analysis.volatility_regime
|
||||
report.current_price = float(primary_df["Close"].iloc[-1])
|
||||
report.timestamp = str(primary_df.index[-1])
|
||||
report.mtf_signals[self.config.primary_timeframe.value] = primary_analysis.composite_signal
|
||||
report.mtf_scores[self.config.primary_timeframe.value] = primary_analysis.composite_score
|
||||
|
||||
# ── 2. Confirmation timeframes ─────────────────────────────
|
||||
for tf in self.config.confirmation_timeframes:
|
||||
cf_df = dfs.get(tf)
|
||||
if cf_df is None or cf_df.empty:
|
||||
continue
|
||||
try:
|
||||
cf_df = self.data_provider.fetch_ohlcv(symbol, tf)
|
||||
cf_analysis = self.tech_engine.analyze(cf_df, symbol, tf.value)
|
||||
report.confirmation_analyses.append(cf_analysis)
|
||||
report.mtf_signals[tf.value] = cf_analysis.composite_signal
|
||||
@@ -189,35 +277,49 @@ class SignalAggregator:
|
||||
except Exception as e:
|
||||
logger.warning(f"Confirmation TF {tf.value} failed for {symbol}: {e}")
|
||||
|
||||
# ── 3. Multi-Timeframe Agreement Check ─────────────────────
|
||||
# ── 3. MTF agreement ───────────────────────────────────────
|
||||
report.mtf_agreement = self._check_mtf_agreement(report)
|
||||
|
||||
# ── 4. Fundamental Context ─────────────────────────────────
|
||||
event_risk, event_desc = self.news_engine.get_event_risk_level(symbol, context)
|
||||
report.event_risk = event_risk
|
||||
report.event_description = event_desc
|
||||
# ── 4. Fundamental context (optional) ──────────────────────
|
||||
if use_news:
|
||||
news = self._get_news_engine()
|
||||
if context is None:
|
||||
context = news.get_fundamental_context()
|
||||
event_risk, event_desc = news.get_event_risk_level(symbol, context)
|
||||
report.event_risk = event_risk
|
||||
report.event_description = event_desc
|
||||
sentiment, sent_desc = news.get_pair_sentiment(symbol, context)
|
||||
report.news_sentiment = sentiment
|
||||
report.news_description = sent_desc
|
||||
else:
|
||||
report.event_risk = "clear"
|
||||
report.event_description = ""
|
||||
report.news_sentiment = 0.0
|
||||
report.news_description = ""
|
||||
|
||||
sentiment, sent_desc = self.news_engine.get_pair_sentiment(symbol, context)
|
||||
report.news_sentiment = sentiment
|
||||
report.news_description = sent_desc
|
||||
# ── 5. Spread estimate from primary data (avoids extra API call) ─
|
||||
try:
|
||||
report.spread_estimate = float(
|
||||
(primary_df["High"] - primary_df["Low"]).median()
|
||||
)
|
||||
except Exception:
|
||||
report.spread_estimate = 0.0
|
||||
|
||||
# ── 5. Spread Estimate ─────────────────────────────────────
|
||||
report.spread_estimate = self.data_provider.get_spread_estimate(symbol)
|
||||
|
||||
# ── 6. Compute Final Signal ────────────────────────────────
|
||||
# ── 6. Final signal ────────────────────────────────────────
|
||||
self._compute_final_signal(report)
|
||||
|
||||
# ── 7. Generate Trade Setup (if signal is actionable) ──────
|
||||
if report.signal_quality in ("A+", "A", "B"):
|
||||
# ── 7. Trade setup for actionable signals ──────────────────
|
||||
if report.signal_quality in ("A+", "A", "B", "C"):
|
||||
report.trade_setup = self._generate_trade_setup(report, pip_value)
|
||||
|
||||
# ── 8. Collect Reasons ─────────────────────────────────────
|
||||
# ── 8. Reasons ─────────────────────────────────────────────
|
||||
self._collect_reasons(report)
|
||||
|
||||
return report
|
||||
|
||||
# ── Internals ──────────────────────────────────────────────────
|
||||
|
||||
def _check_mtf_agreement(self, report: SignalReport) -> bool:
|
||||
"""Check if multiple timeframes agree on direction."""
|
||||
signals = list(report.mtf_signals.values())
|
||||
if len(signals) < 2:
|
||||
return False
|
||||
@@ -229,73 +331,83 @@ class SignalAggregator:
|
||||
return bullish >= threshold or bearish >= threshold
|
||||
|
||||
def _compute_final_signal(self, report: SignalReport):
|
||||
"""
|
||||
Compute the final signal by combining all layers.
|
||||
|
||||
Priority:
|
||||
1. Event risk can downgrade or block signals
|
||||
2. MTF agreement boosts confidence
|
||||
3. News sentiment adds a small bias
|
||||
4. Quality grade combines everything
|
||||
"""
|
||||
score = report.primary_score
|
||||
confidence = report.primary_confidence
|
||||
|
||||
# ── MTF adjustment ─────────────────────────────────────────
|
||||
if report.mtf_agreement:
|
||||
# All timeframes agree — boost confidence and blend scores
|
||||
confidence = min(confidence + 15, 95)
|
||||
confidence += 10
|
||||
all_scores = list(report.mtf_scores.values())
|
||||
if all_scores:
|
||||
mtf_avg = sum(all_scores) / len(all_scores)
|
||||
score = score * 0.6 + mtf_avg * 0.4
|
||||
else:
|
||||
# Timeframes disagree — reduce confidence
|
||||
confidence *= 0.7
|
||||
confidence -= 15
|
||||
if len(report.mtf_scores) >= 2:
|
||||
scores = list(report.mtf_scores.values())
|
||||
has_bull = any(s > 10 for s in scores)
|
||||
has_bear = any(s < -10 for s in scores)
|
||||
if has_bull and has_bear:
|
||||
report.warnings.append("Timeframes CONFLICT — mixed signals across timeframes")
|
||||
confidence *= 0.6
|
||||
|
||||
# ── News sentiment adjustment ──────────────────────────────
|
||||
if abs(report.news_sentiment) > 0.2:
|
||||
# Sentiment aligns with technical
|
||||
if (report.news_sentiment > 0 and score > 0) or \
|
||||
(report.news_sentiment < 0 and score < 0):
|
||||
confidence = min(confidence + 5, 95)
|
||||
# Sentiment conflicts with technical
|
||||
confidence += 5
|
||||
elif (report.news_sentiment > 0 and score < -10) or \
|
||||
(report.news_sentiment < 0 and score > 10):
|
||||
report.warnings.append("News sentiment CONFLICTS with technical signal")
|
||||
confidence *= 0.85
|
||||
confidence -= 10
|
||||
|
||||
# ── Event risk adjustment ──────────────────────────────────
|
||||
if report.event_risk == "danger":
|
||||
report.warnings.append(f"EVENT RISK: {report.event_description}")
|
||||
confidence *= 0.3 # Heavily penalize — event will disrupt price action
|
||||
confidence = min(confidence, 30)
|
||||
report.action_recommendation = f"WAIT — {report.event_description}"
|
||||
elif report.event_risk == "caution":
|
||||
report.warnings.append(f"Upcoming event: {report.event_description}")
|
||||
confidence *= 0.7
|
||||
confidence -= 15
|
||||
|
||||
is_counter_trend = (
|
||||
(report.market_regime == "trending_up" and score < 0) or
|
||||
(report.market_regime == "trending_down" and score > 0)
|
||||
)
|
||||
if is_counter_trend:
|
||||
confidence -= 15
|
||||
report.warnings.append("Counter-trend signal — reduced confidence")
|
||||
|
||||
# ── Volatility regime adjustment ───────────────────────────
|
||||
if report.volatility_regime == "extreme":
|
||||
report.warnings.append("EXTREME volatility — wider stops needed, reduced position size")
|
||||
confidence *= 0.8
|
||||
confidence -= 10
|
||||
elif report.volatility_regime == "low":
|
||||
report.warnings.append("Low volatility — potential for breakout, tight ranges")
|
||||
|
||||
# ── Final signal determination ─────────────────────────────
|
||||
if score >= 40 and confidence >= 65:
|
||||
primary = report.primary_analysis
|
||||
if primary is not None:
|
||||
ema200 = primary.key_levels.get("ema_trend")
|
||||
if ema200 and ema200 > 0 and report.current_price > 0:
|
||||
ema_dist_pct = abs(report.current_price - ema200) / ema200 * 100.0
|
||||
_lo = float(os.environ.get("FB2_EMA_LO", "0.5"))
|
||||
_hi = float(os.environ.get("FB2_EMA_HI", "1.5"))
|
||||
if ema_dist_pct < _lo:
|
||||
report.warnings.append(
|
||||
f"NEAR EMA200 ({ema_dist_pct:.2f}%) — chop risk"
|
||||
)
|
||||
confidence -= 10
|
||||
elif ema_dist_pct > _hi:
|
||||
report.warnings.append(
|
||||
f"FAR FROM EMA200 ({ema_dist_pct:.2f}%) — over-extended"
|
||||
)
|
||||
confidence -= 10
|
||||
|
||||
confidence = max(0.0, min(95.0, confidence))
|
||||
|
||||
# Final signal
|
||||
if score >= 35 and confidence >= 60:
|
||||
report.final_signal = SignalStrength.STRONG_BUY
|
||||
elif score >= 15 and confidence >= 50:
|
||||
elif score >= 12 and confidence >= 45:
|
||||
report.final_signal = SignalStrength.BUY
|
||||
elif score <= -40 and confidence >= 65:
|
||||
elif score <= -35 and confidence >= 60:
|
||||
report.final_signal = SignalStrength.STRONG_SELL
|
||||
elif score <= -15 and confidence >= 50:
|
||||
elif score <= -12 and confidence >= 45:
|
||||
report.final_signal = SignalStrength.SELL
|
||||
else:
|
||||
report.final_signal = SignalStrength.NEUTRAL
|
||||
@@ -303,23 +415,22 @@ class SignalAggregator:
|
||||
report.final_score = score
|
||||
report.final_confidence = confidence
|
||||
|
||||
# ── Quality grade ──────────────────────────────────────────
|
||||
# Quality grade
|
||||
abs_score = abs(score)
|
||||
if abs_score >= 50 and confidence >= 75 and report.mtf_agreement:
|
||||
if abs_score >= 45 and confidence >= 70 and report.mtf_agreement:
|
||||
report.signal_quality = "A+"
|
||||
elif abs_score >= 35 and confidence >= 65 and report.mtf_agreement:
|
||||
elif abs_score >= 30 and confidence >= 60 and report.mtf_agreement:
|
||||
report.signal_quality = "A"
|
||||
elif abs_score >= 25 and confidence >= 55:
|
||||
elif abs_score >= 20 and confidence >= 50:
|
||||
report.signal_quality = "B"
|
||||
elif abs_score >= 15 and confidence >= 45:
|
||||
elif abs_score >= 12 and confidence >= 40:
|
||||
report.signal_quality = "C"
|
||||
elif abs_score >= 10:
|
||||
elif abs_score >= 8:
|
||||
report.signal_quality = "D"
|
||||
else:
|
||||
report.signal_quality = "F"
|
||||
|
||||
# ── Action recommendation ──────────────────────────────────
|
||||
if not report.action_recommendation: # not already set by event risk
|
||||
if not report.action_recommendation:
|
||||
sig_name = report.final_signal.name.replace("_", " ")
|
||||
if report.signal_quality in ("A+", "A"):
|
||||
report.action_recommendation = f"{sig_name} — High-quality setup, consider entry"
|
||||
@@ -331,36 +442,88 @@ class SignalAggregator:
|
||||
report.action_recommendation = "NO TRADE — No clear signal"
|
||||
|
||||
def _generate_trade_setup(self, report: SignalReport, pip_value: float) -> Optional[TradeSetup]:
|
||||
"""Generate entry, SL, TP levels for actionable signals."""
|
||||
if not report.primary_analysis:
|
||||
return None
|
||||
|
||||
price = report.current_price
|
||||
atr = report.primary_analysis.key_levels.get("atr", 0)
|
||||
|
||||
if atr == 0:
|
||||
return None
|
||||
|
||||
is_buy = report.final_signal in (SignalStrength.BUY, SignalStrength.STRONG_BUY)
|
||||
rr = self.config.signals.default_rr_ratio
|
||||
levels = report.primary_analysis.key_levels
|
||||
min_rr = self.config.signals.min_rr_ratio
|
||||
|
||||
# SL = 1.5x ATR from entry (adaptive to volatility)
|
||||
sl_distance = atr * 1.5
|
||||
tp1_distance = sl_distance * rr
|
||||
tp2_distance = sl_distance * rr * 1.5
|
||||
mature_move = abs(report.final_score) > 30
|
||||
tp_mult = 1.5 if mature_move else 2.0
|
||||
tp_swing_cap = 2.5 if mature_move else 3.0
|
||||
|
||||
if is_buy:
|
||||
entry = price
|
||||
sl = price - sl_distance
|
||||
tp1 = price + tp1_distance
|
||||
tp2 = price + tp2_distance
|
||||
swing_lows = sorted(
|
||||
[v for k, v in levels.items() if k.startswith("swing_low_") and v < price],
|
||||
reverse=True,
|
||||
)
|
||||
if swing_lows:
|
||||
sl_price = swing_lows[0] - atr * 1.0
|
||||
else:
|
||||
sl_price = price - atr * 2.0
|
||||
if price - sl_price < atr * 1.5:
|
||||
sl_price = price - atr * 1.5
|
||||
|
||||
sl_distance = price - sl_price
|
||||
|
||||
swing_highs = sorted(
|
||||
v for k, v in levels.items() if k.startswith("swing_high_") and v > price + atr * 0.3
|
||||
)
|
||||
if (swing_highs
|
||||
and swing_highs[0] - price <= atr * tp_swing_cap
|
||||
and swing_highs[0] - price >= sl_distance * min_rr):
|
||||
tp1 = swing_highs[0]
|
||||
else:
|
||||
tp1 = price + max(atr * tp_mult, sl_distance * min_rr)
|
||||
if len(swing_highs) >= 2 and swing_highs[1] - price <= atr * 5.0:
|
||||
tp2 = swing_highs[1]
|
||||
else:
|
||||
tp2 = price + max(atr * (tp_mult + 1.5), sl_distance * min_rr * 1.5)
|
||||
|
||||
direction = "BUY"
|
||||
entry, sl = price, sl_price
|
||||
else:
|
||||
entry = price
|
||||
sl = price + sl_distance
|
||||
tp1 = price - tp1_distance
|
||||
tp2 = price - tp2_distance
|
||||
swing_highs = sorted(
|
||||
v for k, v in levels.items() if k.startswith("swing_high_") and v > price
|
||||
)
|
||||
if swing_highs:
|
||||
sl_price = swing_highs[0] + atr * 1.0
|
||||
else:
|
||||
sl_price = price + atr * 2.0
|
||||
if sl_price - price < atr * 1.5:
|
||||
sl_price = price + atr * 1.5
|
||||
|
||||
sl_distance = sl_price - price
|
||||
|
||||
swing_lows = sorted(
|
||||
[v for k, v in levels.items() if k.startswith("swing_low_") and v < price - atr * 0.3],
|
||||
reverse=True,
|
||||
)
|
||||
if (swing_lows
|
||||
and price - swing_lows[0] <= atr * tp_swing_cap
|
||||
and price - swing_lows[0] >= sl_distance * min_rr):
|
||||
tp1 = swing_lows[0]
|
||||
else:
|
||||
tp1 = price - max(atr * tp_mult, sl_distance * min_rr)
|
||||
if len(swing_lows) >= 2 and price - swing_lows[1] <= atr * 5.0:
|
||||
tp2 = swing_lows[1]
|
||||
else:
|
||||
tp2 = price - max(atr * (tp_mult + 1.5), sl_distance * min_rr * 1.5)
|
||||
|
||||
direction = "SELL"
|
||||
entry, sl = price, sl_price
|
||||
|
||||
tp1_distance = abs(tp1 - entry)
|
||||
rr = tp1_distance / sl_distance if sl_distance > 0 else 0
|
||||
|
||||
if rr < min_rr - 1e-9:
|
||||
return None
|
||||
|
||||
risk_pips = sl_distance / pip_value
|
||||
reward_pips = tp1_distance / pip_value
|
||||
@@ -373,28 +536,19 @@ class SignalAggregator:
|
||||
stop_loss=sl,
|
||||
take_profit_1=tp1,
|
||||
take_profit_2=tp2,
|
||||
risk_reward=rr,
|
||||
risk_reward=round(rr, 2),
|
||||
risk_pips=risk_pips,
|
||||
reward_pips=reward_pips,
|
||||
pip_value=pip_value,
|
||||
)
|
||||
|
||||
def _collect_reasons(self, report: SignalReport):
|
||||
"""
|
||||
Collect bullish/bearish reasons from all indicators.
|
||||
|
||||
Each indicator's description is captured once via the indicators
|
||||
dict. Pattern signals (candlestick) are already included in the
|
||||
'candlestick' indicator description, so we do NOT re-process
|
||||
pattern_signals to avoid duplicate entries.
|
||||
"""
|
||||
if not report.primary_analysis:
|
||||
return
|
||||
|
||||
for name, ind in report.primary_analysis.indicators.items():
|
||||
if name.startswith("_") or ind.weight == 0:
|
||||
continue
|
||||
|
||||
if ind.signal in (SignalStrength.BUY, SignalStrength.STRONG_BUY):
|
||||
prefix = "STRONG: " if ind.signal == SignalStrength.STRONG_BUY else ""
|
||||
report.bullish_reasons.append(f"{prefix}{ind.name}: {ind.description}")
|
||||
@@ -402,7 +556,6 @@ class SignalAggregator:
|
||||
prefix = "STRONG: " if ind.signal == SignalStrength.STRONG_SELL else ""
|
||||
report.bearish_reasons.append(f"{prefix}{ind.name}: {ind.description}")
|
||||
|
||||
# Add news context
|
||||
if report.news_sentiment > 0.1:
|
||||
report.bullish_reasons.append(f"News: {report.news_description}")
|
||||
elif report.news_sentiment < -0.1:
|
||||
|
||||
Executable
+802
@@ -0,0 +1,802 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
ForexBot2 — Telegram Bot
|
||||
========================
|
||||
Async Telegram interface with candle-boundary auto-scanner and
|
||||
real-time WebSocket level-breach monitor.
|
||||
|
||||
Manual scan: 4 pairs × 3 timeframes (M15/H1/H4) via inline buttons.
|
||||
Auto-scan: Starts automatically on boot if TELEGRAM_CHAT_ID is set.
|
||||
/autoscan toggles for additional chats or to stop.
|
||||
M5 fires at :00/:05/:10/… + 10s buffer (data only, no signals).
|
||||
M15 fires at :00/:15/:30/:45 + 10s buffer.
|
||||
H1 fires at :00 + 10s buffer.
|
||||
H4 fires at :00 every 4 hours + 10s buffer.
|
||||
WebSocket: Streams live ticks from TwelveData for EUR/USD & XAU/USD
|
||||
(Grow plan supports only these 2 WS symbols).
|
||||
When price crosses a key structure level (swing S/R, BB,
|
||||
EMA200) cached from the last boundary scan, triggers an
|
||||
immediate M15 scan and sends a Level Break Alert.
|
||||
5-minute cooldown per pair prevents spam.
|
||||
GBP/USD & USD/JPY are monitored via REST scans only.
|
||||
|
||||
Plan: TwelveData Grow (55 credits/min, 8 trial WS credits).
|
||||
Credit budget (worst case, 4-hour boundary):
|
||||
Unique fetches: 4 pairs × ~6 TFs = ~24 calls (rest cached) → fits in 55/min.
|
||||
WebSocket: 2 symbols = 2 credits (one-time on connect).
|
||||
Level breach scans: ~3 REST calls each, ~10/hour worst case.
|
||||
|
||||
Usage:
|
||||
python telegram_bot.py
|
||||
TELEGRAM_TOKEN=<token> TELEGRAM_CHAT_ID=<id> python telegram_bot.py
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from datetime import datetime, timezone
|
||||
from typing import Dict, List, Optional
|
||||
|
||||
import websockets
|
||||
|
||||
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
|
||||
from telegram.constants import ParseMode
|
||||
from telegram.ext import (
|
||||
Application,
|
||||
CallbackQueryHandler,
|
||||
CommandHandler,
|
||||
ContextTypes,
|
||||
)
|
||||
|
||||
from config import (
|
||||
PlatformConfig, SignalStrength, Timeframe,
|
||||
EURUSD, USDJPY, GBPUSD, XAUUSD, PAIR_INFO,
|
||||
)
|
||||
from data_provider import ForexDataProvider
|
||||
from signal_aggregator import SignalAggregator, SignalReport
|
||||
|
||||
# ── Force UTF-8 on Windows ────────────────────────────────────────────
|
||||
if hasattr(sys.stdout, "reconfigure"):
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
|
||||
logging.basicConfig(
|
||||
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
|
||||
level=logging.INFO,
|
||||
datefmt="%H:%M:%S",
|
||||
)
|
||||
logging.getLogger("httpx").setLevel(logging.WARNING)
|
||||
logging.getLogger("httpcore").setLevel(logging.WARNING)
|
||||
logger = logging.getLogger("telegram_bot")
|
||||
|
||||
TOKEN = os.environ.get("TELEGRAM_TOKEN", "8228251480:AAFW2OAyQ2idMicql2t_CIXk1r9-qfRTfNE")
|
||||
CHAT_ID = os.environ.get("TELEGRAM_CHAT_ID", "6025899022")
|
||||
|
||||
# ── Pairs & buttons ───────────────────────────────────────────────────
|
||||
|
||||
SCAN_PAIRS = [EURUSD, USDJPY, GBPUSD, XAUUSD]
|
||||
|
||||
CORRELATION_GROUPS = {
|
||||
"usd_negative": {"pairs": {EURUSD, GBPUSD}, "label": "USD-weakness"},
|
||||
"risk_sentiment": {"pairs": {XAUUSD, USDJPY}, "label": "Risk-sentiment"},
|
||||
}
|
||||
|
||||
_WS_TO_PAIR = {
|
||||
"EUR/USD": EURUSD,
|
||||
"XAU/USD": XAUUSD,
|
||||
}
|
||||
_WS_SYMBOLS = list(_WS_TO_PAIR.keys())
|
||||
|
||||
_LEVEL_KEYS = (
|
||||
"swing_high_1", "swing_high_2", "swing_high_3",
|
||||
"swing_low_1", "swing_low_2", "swing_low_3",
|
||||
"bb_upper", "bb_lower", "ema_trend",
|
||||
)
|
||||
|
||||
SCAN_BUTTONS = [
|
||||
{"cb": "scan_eurusd_m15", "symbol": EURUSD, "tf": Timeframe.M15, "label": "EUR/USD 15M"},
|
||||
{"cb": "scan_eurusd_h1", "symbol": EURUSD, "tf": Timeframe.H1, "label": "EUR/USD 1H"},
|
||||
{"cb": "scan_eurusd_h4", "symbol": EURUSD, "tf": Timeframe.H4, "label": "EUR/USD 4H"},
|
||||
{"cb": "scan_usdjpy_m15", "symbol": USDJPY, "tf": Timeframe.M15, "label": "USD/JPY 15M"},
|
||||
{"cb": "scan_usdjpy_h1", "symbol": USDJPY, "tf": Timeframe.H1, "label": "USD/JPY 1H"},
|
||||
{"cb": "scan_usdjpy_h4", "symbol": USDJPY, "tf": Timeframe.H4, "label": "USD/JPY 4H"},
|
||||
{"cb": "scan_gbpusd_m15", "symbol": GBPUSD, "tf": Timeframe.M15, "label": "GBP/USD 15M"},
|
||||
{"cb": "scan_gbpusd_h1", "symbol": GBPUSD, "tf": Timeframe.H1, "label": "GBP/USD 1H"},
|
||||
{"cb": "scan_gbpusd_h4", "symbol": GBPUSD, "tf": Timeframe.H4, "label": "GBP/USD 4H"},
|
||||
{"cb": "scan_xauusd_m15", "symbol": XAUUSD, "tf": Timeframe.M15, "label": "XAU/USD 15M"},
|
||||
{"cb": "scan_xauusd_h1", "symbol": XAUUSD, "tf": Timeframe.H1, "label": "XAU/USD 1H"},
|
||||
{"cb": "scan_xauusd_h4", "symbol": XAUUSD, "tf": Timeframe.H4, "label": "XAU/USD 4H"},
|
||||
]
|
||||
|
||||
SCAN_LOOKUP = {b["cb"]: b for b in SCAN_BUTTONS}
|
||||
|
||||
TF_CONFIRMATIONS = {
|
||||
Timeframe.M5: [Timeframe.M15, Timeframe.H1],
|
||||
Timeframe.M15: [Timeframe.M5, Timeframe.H1],
|
||||
Timeframe.H1: [Timeframe.M15, Timeframe.H4],
|
||||
Timeframe.H4: [Timeframe.H1, Timeframe.D1],
|
||||
}
|
||||
|
||||
AUTOSCAN_CONFIRMATIONS = {
|
||||
Timeframe.M5: [Timeframe.M15, Timeframe.H1],
|
||||
Timeframe.M15: [Timeframe.M5, Timeframe.H1],
|
||||
Timeframe.H1: [Timeframe.M15, Timeframe.H4],
|
||||
Timeframe.H4: [Timeframe.H1, Timeframe.D1],
|
||||
}
|
||||
|
||||
_executor = ThreadPoolExecutor(max_workers=2)
|
||||
|
||||
|
||||
# ── Shared data provider (single cache across all scans) ─────────────
|
||||
|
||||
_shared_dp: Optional[ForexDataProvider] = None
|
||||
|
||||
|
||||
def _get_shared_dp() -> ForexDataProvider:
|
||||
global _shared_dp
|
||||
if _shared_dp is None:
|
||||
_shared_dp = ForexDataProvider(PlatformConfig())
|
||||
return _shared_dp
|
||||
|
||||
|
||||
# ── Signal formatting ─────────────────────────────────────────────────
|
||||
|
||||
_SIGNAL_EMOJI = {
|
||||
SignalStrength.STRONG_BUY: "🟢",
|
||||
SignalStrength.BUY: "🟩",
|
||||
SignalStrength.NEUTRAL: "⬜",
|
||||
SignalStrength.SELL: "🟥",
|
||||
SignalStrength.STRONG_SELL: "🔴",
|
||||
}
|
||||
|
||||
_QUALITY_EMOJI = {
|
||||
"A+": "🏆", "A": "🥇", "B": "🥈", "C": "🥉", "D": "⚠️", "F": "❌",
|
||||
}
|
||||
|
||||
_ARROW = {
|
||||
SignalStrength.STRONG_BUY: "⬆️",
|
||||
SignalStrength.BUY: "↗️",
|
||||
SignalStrength.NEUTRAL: "➡️",
|
||||
SignalStrength.SELL: "↘️",
|
||||
SignalStrength.STRONG_SELL: "⬇️",
|
||||
}
|
||||
|
||||
|
||||
def _signal_label(sig: SignalStrength) -> str:
|
||||
return sig.name.replace("_", " ")
|
||||
|
||||
|
||||
def _mtf_line(report: SignalReport) -> str:
|
||||
if not report.mtf_signals:
|
||||
return ""
|
||||
parts = []
|
||||
for tf, sig in report.mtf_signals.items():
|
||||
score = report.mtf_scores.get(tf, 0)
|
||||
parts.append(f"{tf}: {_signal_label(sig)} {score:+.1f}")
|
||||
return " | ".join(parts)
|
||||
|
||||
|
||||
def _indicator_line(name: str, ind) -> str:
|
||||
arrow = _ARROW.get(ind.signal, "➡️")
|
||||
short = ind.description.split(" | ")[0] if " | " in ind.description else ind.description
|
||||
return f"{arrow} *{ind.name}*: {short}"
|
||||
|
||||
|
||||
def format_signal_message(report: SignalReport) -> str:
|
||||
sig = report.final_signal
|
||||
emoji = _SIGNAL_EMOJI.get(sig, "⬜")
|
||||
qe = _QUALITY_EMOJI.get(report.signal_quality, "")
|
||||
label = _signal_label(sig)
|
||||
mtf_tag = "✅ MTF aligned" if report.mtf_agreement else "❌ MTF diverged"
|
||||
|
||||
lines: list[str] = []
|
||||
|
||||
now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
|
||||
lines += [
|
||||
f"🔍 *{report.display_name} Signal Analysis* ({report.primary_analysis.timeframe if report.primary_analysis else ''})",
|
||||
f"🕐 {now}",
|
||||
"",
|
||||
f"💰 Price: *{report.current_price:.5f}*" if report.current_price < 10 else f"💰 Price: *{report.current_price:.3f}*",
|
||||
f"📊 Regime: {report.market_regime.replace('_', ' ').title()} | Vol: {report.volatility_regime}",
|
||||
"",
|
||||
"━━━━━━━━━━━━━━━━━━━━",
|
||||
f"{emoji} *{label}* {qe}{report.signal_quality} | Score: {report.final_score:+.1f} | {report.final_confidence:.0f}% conf",
|
||||
f"_{report.action_recommendation}_",
|
||||
f"{mtf_tag}",
|
||||
]
|
||||
|
||||
mtf = _mtf_line(report)
|
||||
if mtf:
|
||||
lines += ["", f"📈 *MTF*: {mtf}"]
|
||||
|
||||
if report.primary_analysis:
|
||||
lines += ["", "━━━━━━━━━━━━━━━━━━━━", "📋 *Indicators*"]
|
||||
for name, ind in report.primary_analysis.indicators.items():
|
||||
if name.startswith("_") or ind.weight == 0:
|
||||
continue
|
||||
lines.append(_indicator_line(name, ind))
|
||||
|
||||
if report.warnings:
|
||||
lines.append("")
|
||||
for w in report.warnings:
|
||||
lines.append(f"⚠️ {w}")
|
||||
|
||||
if report.trade_setup and sig not in (SignalStrength.NEUTRAL,):
|
||||
ts = report.trade_setup
|
||||
dir_emoji = "📈" if ts.direction == "BUY" else "📉"
|
||||
lines += [
|
||||
"",
|
||||
"━━━━━━━━━━━━━━━━━━━━",
|
||||
f"🚀 *TRADE SETUP*",
|
||||
f"{dir_emoji} Direction: *{ts.direction}*",
|
||||
f"▶ Entry: `{ts.entry_price:.3f}`",
|
||||
f"🛑 SL: `{ts.stop_loss:.3f}` ({ts.risk_pips:.1f} pips)",
|
||||
f"🎯 TP1: `{ts.take_profit_1:.3f}` ({ts.reward_pips:.1f} pips)",
|
||||
]
|
||||
if ts.take_profit_2:
|
||||
lines.append(f"🎯 TP2: `{ts.take_profit_2:.3f}`")
|
||||
lines.append(f"⚖️ RR: 1:{ts.risk_reward:.1f}")
|
||||
|
||||
lines += ["", "━━━━━━━━━━━━━━━━━━━━",
|
||||
"_Educational / research use only._"]
|
||||
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
# ── Correlation filter ───────────────────────────────────────────────
|
||||
|
||||
def _detect_correlated_exposure(reports: List[SignalReport]) -> List[str]:
|
||||
warnings = []
|
||||
for group_info in CORRELATION_GROUPS.values():
|
||||
group_pairs = group_info["pairs"]
|
||||
group_label = group_info["label"]
|
||||
active = [
|
||||
r for r in reports
|
||||
if r.symbol in group_pairs
|
||||
and r.final_signal not in (SignalStrength.NEUTRAL,)
|
||||
]
|
||||
if len(active) >= 2:
|
||||
directions = set()
|
||||
for r in active:
|
||||
if r.final_signal in (SignalStrength.BUY, SignalStrength.STRONG_BUY):
|
||||
directions.add("BUY")
|
||||
else:
|
||||
directions.add("SELL")
|
||||
if len(directions) == 1:
|
||||
names = ", ".join(r.display_name for r in active)
|
||||
warnings.append(
|
||||
f"⚠️ Same exposure ({group_label}): {names} both {directions.pop()}"
|
||||
)
|
||||
return warnings
|
||||
|
||||
|
||||
# ── Auto-scan summary format ─────────────────────────────────────────
|
||||
|
||||
def _format_scan_summary(reports: List[SignalReport], tf: Timeframe) -> str:
|
||||
now = datetime.now(timezone.utc).strftime("%H:%M UTC")
|
||||
lines = [
|
||||
f"📊 *{tf.value} Auto-Scan* | {now}",
|
||||
"━━━━━━━━━━━━━━━━━━━━",
|
||||
]
|
||||
for r in reports:
|
||||
emoji = _SIGNAL_EMOJI.get(r.final_signal, "⬜")
|
||||
sig = _signal_label(r.final_signal)
|
||||
mtf = "✅" if r.mtf_agreement else "❌"
|
||||
lines.append(
|
||||
f"{emoji} *{r.display_name}* {sig} "
|
||||
f"{_QUALITY_EMOJI.get(r.signal_quality, '')}{r.signal_quality} "
|
||||
f"{r.final_score:+.1f} {r.final_confidence:.0f}% {mtf}MTF"
|
||||
)
|
||||
lines.append("━━━━━━━━━━━━━━━━━━━━")
|
||||
|
||||
actionable = [r for r in reports if r.signal_quality in ("A+", "A", "B", "C")]
|
||||
if actionable:
|
||||
names = ", ".join(r.display_name for r in actionable)
|
||||
lines.append(f"🔔 Actionable: {names}")
|
||||
else:
|
||||
lines.append("No actionable signals this cycle.")
|
||||
|
||||
corr_warnings = _detect_correlated_exposure(reports)
|
||||
for w in corr_warnings:
|
||||
lines.append(w)
|
||||
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
# ── Keyboard helper ───────────────────────────────────────────────────
|
||||
|
||||
def scan_keyboard() -> InlineKeyboardMarkup:
|
||||
rows = []
|
||||
for i in range(0, len(SCAN_BUTTONS), 4):
|
||||
rows.append([
|
||||
InlineKeyboardButton(b["label"], callback_data=b["cb"])
|
||||
for b in SCAN_BUTTONS[i:i + 4]
|
||||
])
|
||||
return InlineKeyboardMarkup(rows)
|
||||
|
||||
|
||||
# ── Signal runner (shared data provider for cache reuse) ──────────────
|
||||
|
||||
def _run_signal_sync(
|
||||
symbol: str,
|
||||
timeframe: Timeframe,
|
||||
confirmation_tfs: Optional[List[Timeframe]] = None,
|
||||
) -> SignalReport:
|
||||
if confirmation_tfs is None:
|
||||
confirmation_tfs = TF_CONFIRMATIONS.get(
|
||||
timeframe, [Timeframe.M15, Timeframe.H4]
|
||||
)
|
||||
config = PlatformConfig()
|
||||
config.primary_timeframe = timeframe
|
||||
config.confirmation_timeframes = confirmation_tfs
|
||||
aggregator = SignalAggregator(config)
|
||||
aggregator.data_provider = _get_shared_dp()
|
||||
return aggregator.analyze_pair(symbol=symbol)
|
||||
|
||||
|
||||
async def run_signal(
|
||||
symbol: str,
|
||||
timeframe: Timeframe,
|
||||
confirmation_tfs: Optional[List[Timeframe]] = None,
|
||||
) -> SignalReport:
|
||||
loop = asyncio.get_event_loop()
|
||||
return await loop.run_in_executor(
|
||||
_executor, _run_signal_sync, symbol, timeframe, confirmation_tfs
|
||||
)
|
||||
|
||||
|
||||
# ── Candle-boundary scheduler ────────────────────────────────────────
|
||||
|
||||
_autoscan_chats: set[int] = set()
|
||||
_autoscan_tasks: list[asyncio.Task] = []
|
||||
|
||||
|
||||
def _seconds_until_boundary(interval_minutes: int, buffer: int = 10) -> float:
|
||||
"""Seconds until the next candle close + buffer."""
|
||||
now = datetime.now(timezone.utc)
|
||||
total_minutes = now.hour * 60 + now.minute
|
||||
elapsed_minutes = total_minutes % interval_minutes
|
||||
elapsed_seconds = elapsed_minutes * 60 + now.second + now.microsecond / 1e6
|
||||
interval_seconds = interval_minutes * 60
|
||||
remaining = interval_seconds - elapsed_seconds + buffer
|
||||
if remaining <= buffer:
|
||||
remaining += interval_seconds
|
||||
return remaining
|
||||
|
||||
|
||||
async def _scan_timeframe(
|
||||
bot,
|
||||
tf: Timeframe,
|
||||
confirmation_tfs: List[Timeframe],
|
||||
) -> None:
|
||||
"""Scan all pairs for one timeframe and broadcast results."""
|
||||
reports: List[SignalReport] = []
|
||||
for symbol in SCAN_PAIRS:
|
||||
try:
|
||||
report = await run_signal(symbol, tf, confirmation_tfs)
|
||||
reports.append(report)
|
||||
except Exception:
|
||||
logger.exception(f"Auto-scan failed for {symbol} {tf.value}")
|
||||
|
||||
if not reports:
|
||||
return
|
||||
|
||||
_update_level_cache(reports)
|
||||
|
||||
if tf == Timeframe.M5:
|
||||
logger.info("M5 scan: data analysis only — no Telegram broadcast")
|
||||
return
|
||||
|
||||
actionable = [r for r in reports if r.signal_quality in ("A+", "A", "B", "C")]
|
||||
|
||||
if not actionable:
|
||||
logger.info(f"{tf.value} scan: no actionable signals — skipping Telegram message")
|
||||
return
|
||||
|
||||
summary = _format_scan_summary(reports, tf)
|
||||
|
||||
for chat_id in list(_autoscan_chats):
|
||||
try:
|
||||
await bot.send_message(chat_id, summary, parse_mode=ParseMode.MARKDOWN)
|
||||
for report in actionable:
|
||||
detail = format_signal_message(report)
|
||||
await bot.send_message(chat_id, detail, parse_mode=ParseMode.MARKDOWN)
|
||||
except Exception:
|
||||
logger.exception(f"Failed to send to chat {chat_id}")
|
||||
|
||||
|
||||
# ── WebSocket level-breach monitor ──────────────────────────────────
|
||||
|
||||
_level_cache: Dict[str, Dict[str, float]] = {}
|
||||
_last_prices: Dict[str, float] = {}
|
||||
_scan_cooldowns: Dict[str, float] = {}
|
||||
|
||||
_cfg = PlatformConfig()
|
||||
_WS_API_KEY = os.environ.get("TWELVE_DATA_API_KEY") or _cfg.twelve_data_api_key
|
||||
_WS_URL = f"wss://ws.twelvedata.com/v1/quotes/price?apikey={_WS_API_KEY}"
|
||||
_WS_COOLDOWN = _cfg.ws_cooldown_seconds
|
||||
|
||||
|
||||
def _update_level_cache(reports: List[SignalReport]) -> None:
|
||||
for r in reports:
|
||||
if r.primary_analysis and r.primary_analysis.key_levels:
|
||||
levels = {
|
||||
k: v for k, v in r.primary_analysis.key_levels.items()
|
||||
if k in _LEVEL_KEYS
|
||||
}
|
||||
if levels:
|
||||
_level_cache[r.symbol] = levels
|
||||
|
||||
|
||||
def _check_level_breach(symbol: str, price: float) -> Optional[str]:
|
||||
levels = _level_cache.get(symbol)
|
||||
if not levels:
|
||||
return None
|
||||
|
||||
last = _last_prices.get(symbol)
|
||||
if last is None:
|
||||
return None
|
||||
|
||||
for name, level in levels.items():
|
||||
if (last < level <= price) or (last > level >= price):
|
||||
return name
|
||||
|
||||
return None
|
||||
|
||||
|
||||
async def _handle_breach(bot, ws_symbol: str, pair_symbol: str, price: float, level_name: str) -> None:
|
||||
now = time.time()
|
||||
if now - _scan_cooldowns.get(pair_symbol, 0) < _WS_COOLDOWN:
|
||||
return
|
||||
|
||||
_scan_cooldowns[pair_symbol] = now
|
||||
display = PAIR_INFO.get(pair_symbol, {}).get("display", ws_symbol)
|
||||
label = level_name.replace("_", " ").title()
|
||||
logger.info(f"Level breach: {display} crossed {label} at {price}")
|
||||
|
||||
try:
|
||||
report = await run_signal(pair_symbol, Timeframe.M15)
|
||||
_update_level_cache([report])
|
||||
text = (
|
||||
f"🔔 *Level Break — {display}*\n"
|
||||
f"Price crossed *{label}* at `{price}`\n"
|
||||
f"━━━━━━━━━━━━━━━━━━━━\n"
|
||||
+ format_signal_message(report)
|
||||
)
|
||||
except Exception as exc:
|
||||
logger.exception(f"Breach scan failed for {display}")
|
||||
text = f"🔔 *Level Break — {display}*\nPrice crossed {label} at `{price}`\n❌ Scan failed: {exc}"
|
||||
|
||||
for chat_id in list(_autoscan_chats):
|
||||
try:
|
||||
await bot.send_message(chat_id, text, parse_mode=ParseMode.MARKDOWN)
|
||||
except Exception:
|
||||
logger.exception(f"Failed to send breach alert to {chat_id}")
|
||||
|
||||
|
||||
async def _ws_monitor(bot) -> None:
|
||||
backoff = 1
|
||||
while _autoscan_chats:
|
||||
try:
|
||||
async with websockets.connect(_WS_URL) as ws:
|
||||
subscribe = {
|
||||
"action": "subscribe",
|
||||
"params": {"symbols": ",".join(_WS_SYMBOLS)},
|
||||
}
|
||||
await ws.send(json.dumps(subscribe))
|
||||
logger.info(f"WebSocket connected, subscribed to {len(_WS_SYMBOLS)} symbols")
|
||||
backoff = 1
|
||||
|
||||
async for raw in ws:
|
||||
if not _autoscan_chats:
|
||||
break
|
||||
|
||||
msg = json.loads(raw)
|
||||
if msg.get("event") != "price":
|
||||
continue
|
||||
|
||||
ws_symbol = msg.get("symbol")
|
||||
pair_symbol = _WS_TO_PAIR.get(ws_symbol)
|
||||
if not pair_symbol:
|
||||
continue
|
||||
|
||||
price = float(msg["price"])
|
||||
breached = _check_level_breach(pair_symbol, price)
|
||||
_last_prices[pair_symbol] = price
|
||||
|
||||
if breached:
|
||||
asyncio.create_task(
|
||||
_handle_breach(bot, ws_symbol, pair_symbol, price, breached)
|
||||
)
|
||||
|
||||
except asyncio.CancelledError:
|
||||
break
|
||||
except Exception:
|
||||
logger.exception(f"WebSocket error, reconnecting in {backoff}s")
|
||||
await asyncio.sleep(backoff)
|
||||
backoff = min(backoff * 2, 60)
|
||||
|
||||
logger.info("WebSocket monitor stopped")
|
||||
|
||||
|
||||
async def _candle_loop(bot, tf: Timeframe, interval_minutes: int) -> None:
|
||||
label = tf.value
|
||||
try:
|
||||
while _autoscan_chats:
|
||||
wait = _seconds_until_boundary(interval_minutes, buffer=10)
|
||||
logger.info(f"{label} auto-scan: next in {wait:.0f}s")
|
||||
await asyncio.sleep(wait)
|
||||
if not _autoscan_chats:
|
||||
break
|
||||
logger.info(f"{label} auto-scan: firing")
|
||||
await _scan_timeframe(
|
||||
bot, tf, AUTOSCAN_CONFIRMATIONS[tf]
|
||||
)
|
||||
except asyncio.CancelledError:
|
||||
pass
|
||||
finally:
|
||||
logger.info(f"{label} auto-scan loop stopped")
|
||||
|
||||
|
||||
_AUTOSCAN_LOOPS = [
|
||||
(Timeframe.M5, 5),
|
||||
(Timeframe.M15, 15),
|
||||
(Timeframe.H1, 60),
|
||||
(Timeframe.H4, 240),
|
||||
]
|
||||
|
||||
|
||||
_ws_task: Optional[asyncio.Task] = None
|
||||
|
||||
|
||||
def _start_scheduler(bot) -> None:
|
||||
global _ws_task
|
||||
alive = [t for t in _autoscan_tasks if not t.done()]
|
||||
if not alive:
|
||||
_autoscan_tasks.clear()
|
||||
for tf, interval in _AUTOSCAN_LOOPS:
|
||||
_autoscan_tasks.append(
|
||||
asyncio.create_task(_candle_loop(bot, tf, interval))
|
||||
)
|
||||
logger.info("Candle-boundary scheduler started (M5/M15/H1/H4)")
|
||||
|
||||
if _ws_task is None or _ws_task.done():
|
||||
_ws_task = asyncio.create_task(_ws_monitor(bot))
|
||||
logger.info("WebSocket level-breach monitor started")
|
||||
|
||||
|
||||
def _stop_scheduler() -> None:
|
||||
global _ws_task
|
||||
for t in _autoscan_tasks:
|
||||
t.cancel()
|
||||
_autoscan_tasks.clear()
|
||||
if _ws_task and not _ws_task.done():
|
||||
_ws_task.cancel()
|
||||
_ws_task = None
|
||||
logger.info("Candle-boundary scheduler and WebSocket monitor stopped")
|
||||
|
||||
|
||||
# ── Handlers ──────────────────────────────────────────────────────────
|
||||
|
||||
async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
||||
scanning = "running" if _autoscan_chats else "off"
|
||||
text = (
|
||||
"👋 *ForexBot2 — Signal Intelligence*\n\n"
|
||||
"Pick a pair and timeframe to scan.\n"
|
||||
"Signals include a full trade setup with entry, SL and TP.\n\n"
|
||||
f"Auto-scan: *{scanning}* — /autoscan to toggle\n"
|
||||
"/status — Bot & WebSocket status\n"
|
||||
"/help — All commands"
|
||||
)
|
||||
await update.message.reply_text(
|
||||
text,
|
||||
parse_mode=ParseMode.MARKDOWN,
|
||||
reply_markup=scan_keyboard(),
|
||||
)
|
||||
|
||||
|
||||
async def cmd_help(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
||||
text = (
|
||||
"📖 *ForexBot2 Commands*\n\n"
|
||||
"/start — Show scan buttons (4 pairs × 4 TFs)\n"
|
||||
"/autoscan — Toggle auto-scan on/off\n"
|
||||
"/status — Bot status, WS connection, live prices\n"
|
||||
"/help — This message\n\n"
|
||||
"*Auto-scan* fires at candle close: M5/M15/H1/H4.\n"
|
||||
"*WebSocket* monitors live prices and sends Level Break Alerts "
|
||||
"when price crosses swing S/R, Bollinger bands, or EMA200."
|
||||
)
|
||||
await update.message.reply_text(text, parse_mode=ParseMode.MARKDOWN)
|
||||
|
||||
|
||||
async def cmd_status(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
||||
lines = ["📊 *ForexBot2 Status*\n"]
|
||||
|
||||
if _autoscan_chats:
|
||||
lines.append(f"✅ Auto-scan: *running* ({len(_autoscan_chats)} chat)")
|
||||
tasks_alive = sum(1 for t in _autoscan_tasks if not t.done())
|
||||
lines.append(f" Candle loops: {tasks_alive}/{len(_AUTOSCAN_LOOPS)}")
|
||||
else:
|
||||
lines.append("⏹ Auto-scan: *stopped*")
|
||||
|
||||
if _ws_task and not _ws_task.done():
|
||||
lines.append("📡 WebSocket: *connected*")
|
||||
else:
|
||||
lines.append("❌ WebSocket: *disconnected*")
|
||||
|
||||
if _last_prices:
|
||||
lines.append("\n*Live Prices:*")
|
||||
for pair in SCAN_PAIRS:
|
||||
price = _last_prices.get(pair)
|
||||
display = PAIR_INFO.get(pair, {}).get("display", pair)
|
||||
if price is None:
|
||||
lines.append(f" {display}: waiting...")
|
||||
elif price < 10:
|
||||
lines.append(f" {display}: `{price:.5f}`")
|
||||
else:
|
||||
lines.append(f" {display}: `{price:.3f}`")
|
||||
else:
|
||||
lines.append("\n_No live prices yet (WS not streaming)_")
|
||||
|
||||
cached_pairs = len(_level_cache)
|
||||
cached_levels = sum(len(v) for v in _level_cache.values())
|
||||
if cached_levels:
|
||||
lines.append(f"\n*Level Cache:* {cached_levels} levels across {cached_pairs} pairs")
|
||||
else:
|
||||
lines.append("\n*Level Cache:* empty — breach alerts start after first candle scan")
|
||||
|
||||
active_cooldowns = sum(
|
||||
1 for v in _scan_cooldowns.values()
|
||||
if time.time() - v < _WS_COOLDOWN
|
||||
)
|
||||
if active_cooldowns:
|
||||
lines.append(f"*Cooldowns:* {active_cooldowns} pair(s) in cooldown")
|
||||
|
||||
await update.message.reply_text("\n".join(lines), parse_mode=ParseMode.MARKDOWN)
|
||||
|
||||
|
||||
async def cmd_autoscan(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
||||
chat_id = update.effective_chat.id
|
||||
|
||||
if chat_id in _autoscan_chats:
|
||||
_autoscan_chats.discard(chat_id)
|
||||
if not _autoscan_chats:
|
||||
_stop_scheduler()
|
||||
await update.message.reply_text(
|
||||
"⏹ Auto-scan stopped.",
|
||||
parse_mode=ParseMode.MARKDOWN,
|
||||
)
|
||||
return
|
||||
|
||||
_autoscan_chats.add(chat_id)
|
||||
_start_scheduler(context.bot)
|
||||
|
||||
next_m5 = _seconds_until_boundary(5, buffer=10)
|
||||
next_m15 = _seconds_until_boundary(15, buffer=10)
|
||||
next_h1 = _seconds_until_boundary(60, buffer=10)
|
||||
next_h4 = _seconds_until_boundary(240, buffer=10)
|
||||
await update.message.reply_text(
|
||||
"✅ *Auto-scan enabled*\n\n"
|
||||
f"Scanning {len(SCAN_PAIRS)} pairs on M5/M15/H1/H4 at candle close.\n"
|
||||
f"📡 Live price monitoring active — level-break alerts enabled.\n"
|
||||
f"Next: M5 {next_m5 / 60:.0f}m | M15 {next_m15 / 60:.0f}m | "
|
||||
f"H1 {next_h1 / 60:.0f}m | H4 {next_h4 / 60:.0f}m\n\n"
|
||||
"Use /autoscan again to stop.",
|
||||
parse_mode=ParseMode.MARKDOWN,
|
||||
)
|
||||
|
||||
|
||||
async def cb_scan(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
||||
query = update.callback_query
|
||||
await query.answer()
|
||||
|
||||
btn = SCAN_LOOKUP.get(query.data)
|
||||
if not btn:
|
||||
return
|
||||
|
||||
pair_display = btn["label"]
|
||||
await query.edit_message_text(
|
||||
f"⏳ Scanning {pair_display}…",
|
||||
parse_mode=ParseMode.MARKDOWN,
|
||||
)
|
||||
|
||||
try:
|
||||
report = await run_signal(btn["symbol"], btn["tf"])
|
||||
text = format_signal_message(report)
|
||||
except Exception as exc:
|
||||
logger.exception("Signal scan failed")
|
||||
text = f"❌ Scan failed: {exc}"
|
||||
|
||||
await query.edit_message_text(
|
||||
text,
|
||||
parse_mode=ParseMode.MARKDOWN,
|
||||
reply_markup=scan_keyboard(),
|
||||
)
|
||||
|
||||
|
||||
# ── Boot-time auto-start ──────────────────────────────────────────────
|
||||
|
||||
async def _post_init(app: Application) -> None:
|
||||
"""Register command menu and start scheduler on boot."""
|
||||
await app.bot.set_my_commands([
|
||||
("start", "Show scan buttons"),
|
||||
("autoscan", "Toggle auto-scan on/off"),
|
||||
("status", "Bot status, WS connection, live prices"),
|
||||
("help", "All commands"),
|
||||
])
|
||||
|
||||
if not CHAT_ID:
|
||||
logger.info("TELEGRAM_CHAT_ID not set — auto-scan disabled on boot. "
|
||||
"Use /autoscan in chat to enable.")
|
||||
return
|
||||
|
||||
chat_id = int(CHAT_ID)
|
||||
_autoscan_chats.add(chat_id)
|
||||
|
||||
logger.info("Running initial scan to populate level cache for WebSocket monitor...")
|
||||
try:
|
||||
init_reports = []
|
||||
for symbol in SCAN_PAIRS:
|
||||
report = await run_signal(symbol, Timeframe.M15)
|
||||
init_reports.append(report)
|
||||
_update_level_cache(init_reports)
|
||||
logger.info(f"Level cache populated: {sum(len(v) for v in _level_cache.values())} levels")
|
||||
except Exception:
|
||||
logger.exception("Initial scan failed — WS will wait for first candle scan")
|
||||
|
||||
_start_scheduler(app.bot)
|
||||
|
||||
next_m5 = _seconds_until_boundary(5, buffer=10)
|
||||
next_m15 = _seconds_until_boundary(15, buffer=10)
|
||||
next_h1 = _seconds_until_boundary(60, buffer=10)
|
||||
next_h4 = _seconds_until_boundary(240, buffer=10)
|
||||
logger.info(
|
||||
f"Auto-scan started for chat {chat_id} — "
|
||||
f"M5 {next_m5:.0f}s, M15 {next_m15:.0f}s, H1 {next_h1:.0f}s, H4 {next_h4:.0f}s"
|
||||
)
|
||||
|
||||
try:
|
||||
await app.bot.send_message(
|
||||
chat_id,
|
||||
f"🤖 *ForexBot2 started*\n\n"
|
||||
f"Auto-scanning {len(SCAN_PAIRS)} pairs on M5/M15/H1/H4.\n"
|
||||
f"📡 Live price monitoring active — level-break alerts enabled.\n"
|
||||
f"Next: M5 {next_m5 / 60:.0f}m | M15 {next_m15 / 60:.0f}m | "
|
||||
f"H1 {next_h1 / 60:.0f}m | H4 {next_h4 / 60:.0f}m\n\n"
|
||||
f"/autoscan to stop | Manual buttons via /start",
|
||||
parse_mode=ParseMode.MARKDOWN,
|
||||
)
|
||||
except Exception:
|
||||
logger.exception("Failed to send boot message")
|
||||
|
||||
|
||||
# ── Entry point ───────────────────────────────────────────────────────
|
||||
|
||||
def main() -> None:
|
||||
if not TOKEN:
|
||||
sys.exit("TELEGRAM_TOKEN not set")
|
||||
|
||||
logger.info("Starting ForexBot2 Telegram bot…")
|
||||
|
||||
app = (
|
||||
Application.builder()
|
||||
.token(TOKEN)
|
||||
.post_init(_post_init)
|
||||
.build()
|
||||
)
|
||||
|
||||
app.add_handler(CommandHandler("start", cmd_start))
|
||||
app.add_handler(CommandHandler("help", cmd_help))
|
||||
app.add_handler(CommandHandler("status", cmd_status))
|
||||
app.add_handler(CommandHandler("autoscan", cmd_autoscan))
|
||||
app.add_handler(CallbackQueryHandler(cb_scan, pattern="^scan_"))
|
||||
|
||||
logger.info("Bot running — press Ctrl+C to stop")
|
||||
app.run_polling(allowed_updates=Update.ALL_TYPES)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+55
@@ -0,0 +1,55 @@
|
||||
"""Live tick stream from Twelve Data WebSocket API."""
|
||||
|
||||
import json
|
||||
import asyncio
|
||||
import websockets
|
||||
from datetime import datetime, timezone
|
||||
|
||||
|
||||
API_KEY = "f563b22ffdfd4924955decbe1a8c8701"
|
||||
WS_URL = f"wss://ws.twelvedata.com/v1/quotes/price?apikey={API_KEY}"
|
||||
SYMBOLS = ["EUR/USD", "XAU/USD"]
|
||||
|
||||
|
||||
async def stream_ticks():
|
||||
async with websockets.connect(WS_URL) as ws:
|
||||
subscribe = {
|
||||
"action": "subscribe",
|
||||
"params": {
|
||||
"symbols": ",".join(SYMBOLS),
|
||||
},
|
||||
}
|
||||
await ws.send(json.dumps(subscribe))
|
||||
print(f"Subscribed to: {', '.join(SYMBOLS)}")
|
||||
print("-" * 60)
|
||||
|
||||
async for raw in ws:
|
||||
msg = json.loads(raw)
|
||||
|
||||
if msg.get("event") == "subscribe-status":
|
||||
print(f"Status: {msg.get('status')} — {msg.get('message', '')}")
|
||||
continue
|
||||
|
||||
if msg.get("event") == "heartbeat":
|
||||
continue
|
||||
|
||||
if msg.get("event") == "price":
|
||||
ts = datetime.fromtimestamp(msg["timestamp"], tz=timezone.utc)
|
||||
symbol = msg["symbol"]
|
||||
price = msg["price"]
|
||||
print(f"{ts:%H:%M:%S} | {symbol:<8} | {price}")
|
||||
|
||||
|
||||
async def main():
|
||||
print(f"Connecting to Twelve Data WebSocket...")
|
||||
print(f"API key: ...{API_KEY[-6:]}")
|
||||
try:
|
||||
await stream_ticks()
|
||||
except KeyboardInterrupt:
|
||||
print("\nStopped.")
|
||||
except websockets.exceptions.ConnectionClosed as e:
|
||||
print(f"\nConnection closed: {e}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
Reference in New Issue
Block a user