cbazzaandClaude Opus 4.5
ff23c0b99e
Deploy to Windows VPS / deploy (push) Has been cancelled
Previous fix with json.dump didn't preserve the escape sequences correctly. Using nbformat ensures proper handling of Python string literals in notebook cells. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
176 KiB
176 KiB
In [ ]:
# ==========================================
# INSTALL TELEGRAM DEPENDENCIES (Run FIRST!)
# ==========================================
import sys
import subprocess
print("📦 Installing python-telegram-bot...")
subprocess.check_call([
sys.executable, "-m", "pip", "install",
"python-telegram-bot", "--upgrade"
])
print("\n✅ python-telegram-bot installed!")
# Verify
import telegram
print(f"✅ Version: {telegram.__version__}")
print(f"\n🎯 Now restart kernel and run Cell 17 again!")📦 Installing python-telegram-bot...
In [ ]:
# Standard Imports
import pandas as pd
import numpy as np
import MetaTrader5 as mt
import pandas_ta as ta
from scipy.signal import savgol_filter, find_peaks
from sklearn.linear_model import LinearRegression
from tabulate import tabulate
from datetime import datetime, timedelta, time
import json
import keyring as kr
# V1.6: Zusätzliche Imports für Adaptive Rhythm
import pytz
import logging
from apscheduler.schedulers.background import BackgroundScheduler
# Setup Logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
print("✅ All imports successful - V1.6 Adaptive Complete (CORRECTED)")In [ ]:
# ==========================================
# INFRASTRUCTURE IMPORTS (V1.8)
# ==========================================
from infrastructure_patch import (
TradingInfrastructure,
create_scheduled_reports
)
from trading_database import TradingDatabase
from telegram_notifier import TelegramNotifier
print("✅ Infrastructure modules loaded")In [ ]:
# ============================================================================
# CENTRALIZED TRADING CONFIGURATION
# ============================================================================
# All trading parameters should be configured here and referenced throughout
# the notebook to avoid scattered settings
TRADING_CONFIG = {
# ========================================================================
# LOT SIZING & POSITION MANAGEMENT
# ========================================================================
'lot_sizing': {
'min_lot': 0.01, # Minimum lot size (reduced for Equity Curve)
'max_lot': 0.20, # Maximum lot size
'default_lot': 0.10, # Fallback lot size
'use_adaptive': True, # Use adaptive position sizing
},
# ========================================================================
# RISK MANAGEMENT
# ========================================================================
'risk': {
'max_risk_per_trade': 0.02, # 2% max risk per trade
'max_positions': 1, # Maximum concurrent positions
'max_daily_loss': 0.05, # 5% max daily loss
},
# ========================================================================
# CONFIDENCE THRESHOLDS
# ========================================================================
'confidence': {
'base_threshold': 70, # Base confidence threshold (all sessions)
'ny_threshold': 70, # NY session threshold (was 97, reduced for more trades)
'asian_threshold': 70, # Asian session threshold
'london_threshold': 70, # London session threshold
},
# ========================================================================
# ATR & STOP LOSS
# ========================================================================
'atr': {
'base_multiplier': 1.5, # Base ATR multiplier for SL/TP
'period': 14, # ATR calculation period
},
# ========================================================================
# NEWS FILTER
# ========================================================================
'news_filter': {
'enabled': True, # Enable/disable news filter
'minutes_before': 30, # Minutes before event to block
'minutes_after': 30, # Minutes after event to block
},
# ========================================================================
# SESSION SETTINGS
# ========================================================================
'sessions': {
'asian_enabled': True,
'london_enabled': False, # Currently disabled
'ny_enabled': True,
'overlap_enabled': False, # Currently disabled
},
# ========================================================================
# TRADING SYMBOLS
# ========================================================================
'symbols': {
'primary': 'XAUUSD', # Primary trading symbol (Gold)
'alternative': [], # Alternative symbols (if needed)
},
}
# ============================================================================
# HELPER FUNCTIONS
# ============================================================================
def get_config(section, key=None):
"""Get configuration value"""
if key is None:
return TRADING_CONFIG.get(section, {})
return TRADING_CONFIG.get(section, {}).get(key)
def update_config(section, key, value):
"""Update configuration value (runtime only, doesn't save to notebook)"""
if section not in TRADING_CONFIG:
TRADING_CONFIG[section] = {}
TRADING_CONFIG[section][key] = value
print(f"✅ Updated: {section}.{key} = {value}")
# Print current configuration
print("✅ TRADING CONFIGURATION LOADED")
print()
print(f"📊 Lot Sizing: {TRADING_CONFIG['lot_sizing']['min_lot']} - {TRADING_CONFIG['lot_sizing']['max_lot']} lots")
print(f"⚠️ Max Risk: {TRADING_CONFIG['risk']['max_risk_per_trade']*100}% per trade")
print(f"🎯 Confidence Threshold: {TRADING_CONFIG['confidence']['base_threshold']}%")
print(f"🛡️ News Filter: {'ENABLED' if TRADING_CONFIG['news_filter']['enabled'] else 'DISABLED'}")
print(f"🌍 Primary Symbol: {TRADING_CONFIG['symbols']['primary']}")In [ ]:
class AdaptiveRhythmManager:
"""
🆕 V1.6 Feature: Adaptive Trading Rhythm
Verwaltet adaptiven Trading-Rhythmus basierend auf:
- Marktvolatilität (ATR)
- Trading-Session (Asian/London/NY/Overlap)
- Marktregime
"""
def __init__(self, symbol="XAUUSD"):
self.symbol = symbol
self.current_interval = 5
# Zeitintervalle in Minuten
self.intervals = {
'fast': 5, # Hohe Volatilität, aktive Sessions
'medium': 15, # Moderate Volatilität, Standard
'slow': 30 # Niedrige Volatilität, ruhige Sessions
}
# ATR-Schwellenwerte für XAUUSD (Gold)
self.atr_thresholds = {
'high': 15.0, # Hohe Volatilität
'medium': 8.0, # Moderate Volatilität
'low': 5.0 # Niedrige Volatilität
}
# Session-Zeiten (UTC)
self.sessions = {
'asian': (time(0, 0), time(8, 0)), # 00:00-08:00 UTC
'london': (time(8, 0), time(16, 0)), # 08:00-16:00 UTC
'ny': (time(13, 0), time(21, 0)), # 13:00-21:00 UTC
'overlap': (time(13, 0), time(16, 0)) # London-NY Overlap
}
def get_current_session(self):
"""Ermittelt die aktuelle Trading-Session"""
now_utc = datetime.now(pytz.UTC).time()
# Overlap hat höchste Priorität
if self.sessions['overlap'][0] <= now_utc <= self.sessions['overlap'][1]:
return 'overlap'
elif self.sessions['london'][0] <= now_utc < self.sessions['london'][1]:
return 'london'
elif self.sessions['ny'][0] <= now_utc < self.sessions['ny'][1]:
return 'ny'
return 'asian'
def get_volatility_level(self, atr_value):
"""Klassifiziert die Volatilität basierend auf ATR"""
if atr_value >= self.atr_thresholds['high']:
return 'high'
elif atr_value >= self.atr_thresholds['medium']:
return 'medium'
return 'low'
def get_market_data(self):
"""Hole Marktdaten für ATR-Analyse"""
try:
rates = mt.copy_rates_from_pos(self.symbol, mt.TIMEFRAME_H1, 0, 50)
if rates is None:
return None
df = pd.DataFrame(rates)
df['time'] = pd.to_datetime(df['time'], unit='s')
df.set_index('time', inplace=True)
df['atr'] = ta.atr(df['high'], df['low'], df['close'], length=14)
return df
except Exception as e:
logger.error(f"Fehler beim Laden der Marktdaten: {e}")
return None
def calculate_optimal_interval(self):
"""Berechnet optimales Trading-Intervall"""
session = self.get_current_session()
df = self.get_market_data()
if df is None:
return self.current_interval
current_atr = df['atr'].iloc[-1]
volatility = self.get_volatility_level(current_atr)
optimal_interval = self._determine_interval(session, volatility)
# Logge Änderungen
if optimal_interval != self.current_interval:
logger.info(f"🔄 Rhythmus-Änderung: {self.current_interval}m → {optimal_interval}m")
logger.info(f" Session: {session}, Volatilität: {volatility} (ATR: {current_atr:.2f})")
self.current_interval = optimal_interval
return optimal_interval
def _determine_interval(self, session, volatility):
"""
Intervall-Entscheidungs-Matrix:
Session │ Hohe Vol │ Mittlere Vol │ Niedrige Vol
───────────┼──────────┼──────────────┼─────────────
Overlap │ 5min │ 15min │ 15min
London/NY │ 5min │ 15min │ 30min
Asian │ 15min │ 30min │ 30min
"""
if session == 'overlap':
return self.intervals['fast'] if volatility == 'high' else self.intervals['medium']
elif session in ['london', 'ny']:
if volatility == 'high':
return self.intervals['fast']
elif volatility == 'medium':
return self.intervals['medium']
return self.intervals['slow']
else: # asian
return self.intervals['medium'] if volatility == 'high' else self.intervals['slow']
def get_status_report(self):
"""Erstellt Status-Report"""
session = self.get_current_session()
df = self.get_market_data()
if df is not None:
current_atr = df['atr'].iloc[-1]
volatility = self.get_volatility_level(current_atr)
else:
current_atr = 0
volatility = 'unknown'
return f"""
╔════════════════════════════════════════════════════════╗
║ ADAPTIVE RHYTHM STATUS - {datetime.now().strftime('%H:%M:%S UTC')} ║
╠════════════════════════════════════════════════════════╣
║ Aktuelles Intervall: {self.current_interval:>2} Minuten ║
║ Trading Session: {session.upper():<15} ║
║ Volatilitätslevel: {volatility.upper():<15} ║
║ ATR (H1): {current_atr:>6.2f} ║
╠════════════════════════════════════════════════════════╣
║ INTERVALL-SCHEMA: ║
║ • Overlap (13-16 UTC): 5-15 Min (aktivste Phase) ║
║ • London/NY: 5-30 Min (volatilitätsabh.) ║
║ • Asian Session: 15-30 Min (ruhigere Phase) ║
╚════════════════════════════════════════════════════════╝
"""
print("✅ Adaptive Rhythm Manager defined")In [ ]:
# MT5 Login
mt.initialize()
login = 10800246
server = 'VantageInternational-Demo'
password = kr.get_password(server, str(login))
login_result = mt.login(login, password, server)
print(f"Login successful: {login_result}")
# Trading Parameter
symbol = "XAUUSD"
strategy_name = "TradingBot_V1.6"
max_positions = 1
print(f"Symbol: {symbol}")
print(f"Strategy: {strategy_name}")
print(f"Max Positions: {max_positions}")
print(f"Version: V1.6 COMPLETE - Adaptive + Full Features! 🚀🛡️⚡")
# 🆕 Initialisiere Adaptive Rhythm Manager
rhythm_manager = AdaptiveRhythmManager(symbol)
print("\n" + rhythm_manager.get_status_report())In [ ]:
# ==========================================
# INITIALIZE INFRASTRUCTURE (V1.8)
# ==========================================
print("🔧 Initializing Infrastructure...")
# Initialize Infrastructure
infra = TradingInfrastructure(
db_path="trading_bot.db",
enable_telegram=True,
enable_database=True
)
# Bot Started Notification
from session_filter_patch import SESSION_WHITELIST_CONFIG
bot_config = {
'version': 'V1.8',
'enabled_sessions': SESSION_WHITELIST_CONFIG['enabled_sessions'],
'base_confidence': SESSION_WHITELIST_CONFIG['base_confidence'],
'max_risk_per_trade': SESSION_WHITELIST_CONFIG['max_risk_per_trade']
}
infra.send_bot_started(bot_config)
print("✅ Infrastructure ready!")
print(f" Database: {'✅' if infra.enable_database else '❌'}")
print(f" Telegram: {'✅' if infra.enable_telegram else '❌'}")In [ ]:
# ==========================================
# ADVANCED POSITION MANAGEMENT SETUP
# ==========================================
from session_filter_patch import SESSION_WHITELIST_CONFIG
from advanced_position_management import AdvancedPositionManager
print("🎯 Initializing Advanced Position Management...")
# Initialize Manager with all features
adv_position_mgr = AdvancedPositionManager(
enable_adaptive_sizing=True, # ✅ Adaptive Position Sizing
enable_trailing_stop=True, # ✅ Trailing Stop-Loss
enable_partial_tp=True, # ✅ Partial Take Profit
base_risk=SESSION_WHITELIST_CONFIG['max_risk_per_trade'] # ✅ 2% Base Risk from config
)
print("✅ Advanced Position Management activated!")
print(" 📊 Adaptive Position Sizing: ACTIVE")
print(" • High Confidence (≥80%): 1.5x risk")
print(" • Medium Confidence (≥70%): 1.0x risk")
print(" • Low Confidence (<70%): 0.5x risk")
print("")
print(" 📈 Trailing Stop-Loss: ACTIVE")
print(" • Break-Even at 50% progress to TP")
print(" • Lock 50% profit at 75% progress")
print("")
print(" 🎯 Partial Take Profit: ACTIVE")
print(" • TP1 at 1.5R (close 50%)")
print(" • TP2 at 2.5R (let 50% run)")
In [ ]:
# ==========================================
# POSITION MONITOR SETUP (V1.8)
# ==========================================
from position_monitor import PositionMonitor
print("🔧 Initializing Position Monitor...")
# Create Position Monitor
position_monitor = PositionMonitor(infra.db, infra.telegram)
print("✅ Position Monitor ready!")
print(" Will check for closed positions every minute")
print(" Closed trades will be automatically logged with:")
print(" • Exit price & time")
print(" • Profit/Loss calculation")
print(" • Exit reason (TP/SL/Manual)")
print(" • Telegram notification")In [ ]:
def check_existing_positions(symbol="XAUUSD", strategy_name="TradingBot_V1.6"):
"""
Überprüft ob bereits Positionen für das Symbol und die Strategie existieren
"""
try:
positions = mt.positions_get(symbol=symbol)
if positions is None:
return False, {"count": 0, "details": []}
strategy_positions = []
for pos in positions:
if strategy_name in pos.comment:
strategy_positions.append({
"ticket": pos.ticket,
"type": "BUY" if pos.type == 0 else "SELL",
"volume": pos.volume,
"price_open": pos.price_open,
"profit": pos.profit,
"comment": pos.comment,
"time_open": pd.to_datetime(pos.time, unit='s')
})
has_position = len(strategy_positions) > 0
position_info = {"count": len(strategy_positions), "details": strategy_positions}
return has_position, position_info
except Exception as e:
print(f"Error checking positions: {e}")
return False, {"count": 0, "details": []}
def get_position_summary(symbol="XAUUSD", strategy_name="TradingBot_V1.6"):
"""Position-Zusammenfassung"""
has_position, position_info = check_existing_positions(symbol, strategy_name)
print(f"\n📊 POSITION SUMMARY für {symbol} (V1.6 Adaptive Complete)")
print("=" * 60)
if not has_position:
print("✅ Keine aktiven Positionen - bereit für neuen Trade")
return False
print(f"⚠️ {position_info['count']} aktive Position(en) gefunden:")
for i, pos in enumerate(position_info['details'], 1):
profit_emoji = "🟢" if pos['profit'] >= 0 else "🔴"
print(f"\n Position {i}:")
print(f" Ticket: {pos['ticket']}")
print(f" Typ: {pos['type']}")
print(f" Volumen: {pos['volume']}")
print(f" Eröffnungspreis: {pos['price_open']}")
print(f" Profit: {profit_emoji} {pos['profit']:.2f}")
print(f" Eröffnungszeit: {pos['time_open']}")
print(f"\n🛑 TRADING BLOCKIERT - Maximal {max_positions} Position erlaubt")
return True
def close_existing_positions(symbol="XAUUSD", strategy_name="TradingBot_V1.6", force_close=False):
"""
✅ KORRIGIERT: Schließt bestehende Positionen (optional)
Diese Funktion fehlte in der ursprünglichen V1.6!
"""
has_position, position_info = check_existing_positions(symbol, strategy_name)
if not has_position:
print("✅ Keine Positionen zum Schließen")
return True
if not force_close:
print(f"⚠️ {position_info['count']} Position(en) gefunden. Verwende force_close=True zum Schließen.")
return False
print(f"🔄 Schließe {position_info['count']} Position(en)...")
success_count = 0
for pos in position_info['details']:
try:
# Position schließen
close_request = {
"action": mt.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": pos['volume'],
"type": mt.ORDER_TYPE_SELL if pos['type'] == "BUY" else mt.ORDER_TYPE_BUY,
"position": pos['ticket'],
"price": mt.symbol_info_tick(symbol).bid if pos['type'] == "BUY" else mt.symbol_info_tick(symbol).ask,
"deviation": 20,
"magic": 234000,
"comment": f"Close {strategy_name}",
"type_time": mt.ORDER_TIME_GTC,
"type_filling": mt.ORDER_FILLING_IOC,
}
result = mt.order_send(close_request)
if result.retcode == mt.TRADE_RETCODE_DONE:
print(f"✅ Position {pos['ticket']} erfolgreich geschlossen")
success_count += 1
else:
print(f"❌ Fehler beim Schließen von Position {pos['ticket']}: {result.comment}")
except Exception as e:
print(f"❌ Exception beim Schließen von Position {pos['ticket']}: {e}")
print(f"📊 {success_count}/{len(position_info['details'])} Positionen erfolgreich geschlossen")
return success_count == len(position_info['details'])
print("✅ Position Control functions defined (COMPLETE with close function!)")In [ ]:
import time
def get_rates(timeframe="h4", count=200, symbol="XAUUSD", max_retries=3):
"""Hole Kursdaten mit Retry-Logik"""
timeframes_dict = {
"m1": mt.TIMEFRAME_M1, "m5": mt.TIMEFRAME_M5, "m15": mt.TIMEFRAME_M15,
"m30": mt.TIMEFRAME_M30, "h1": mt.TIMEFRAME_H1, "h4": mt.TIMEFRAME_H4,
"d1": mt.TIMEFRAME_D1
}
for attempt in range(max_retries):
try:
# Check if MT5 is initialized
if not mt.initialize():
print(f"⚠️ MT5 not initialized, attempting to reconnect...")
time.sleep(1)
continue
# Check symbol is selected
symbol_info = mt.symbol_info(symbol)
if symbol_info is None:
print(f"⚠️ Symbol {symbol} not found")
return None
if not symbol_info.visible:
if not mt.symbol_select(symbol, True):
print(f"⚠️ Failed to select symbol {symbol}")
return None
# Get rates
rates = mt.copy_rates_from_pos(symbol, timeframes_dict[timeframe], 0, count)
if rates is None or len(rates) == 0:
if attempt < max_retries - 1:
print(f" ⏳ No data for {timeframe.upper()}, retry {attempt + 1}/{max_retries}...")
time.sleep(2) # Longer wait for D1
continue
else:
print(f" ❌ No data for {timeframe.upper()} after {max_retries} retries")
return None
# Convert to DataFrame
df = pd.DataFrame(rates)
df['time'] = pd.to_datetime(df['time'], unit='s')
df.set_index('time', inplace=True)
df['atr'] = ta.atr(df['high'], df['low'], df['close'], length=14)
return df
except Exception as e:
if attempt < max_retries - 1:
print(f" ⚠️ Error loading {timeframe.upper()}: {e}, retry {attempt + 1}/{max_retries}...")
time.sleep(2)
else:
print(f" ❌ Error loading {timeframe.upper()} after {max_retries} retries: {e}")
return None
return None
def check_risk_limits(symbol, volume=None, order_type="buy", max_risk_per_trade=0.01):
"""Risk Management"""
try:
account_info = mt.account_info()
if not account_info:
return False
balance, equity = account_info.balance, account_info.equity
if equity < balance * 0.8:
return False
return True
except:
return False
def market_order(symbol, volume, order_type, stoploss=0, take_profit=0, deviation=20):
"""Market Order Execution"""
try:
price_dict = {"buy": mt.symbol_info_tick(symbol).ask, "sell": mt.symbol_info_tick(symbol).bid}
order_type_dict = {"buy": mt.ORDER_TYPE_BUY, "sell": mt.ORDER_TYPE_SELL}
request = {
"action": mt.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": volume,
"type": order_type_dict[order_type],
"price": price_dict[order_type],
"sl": stoploss,
"tp": take_profit,
"deviation": deviation,
"magic": 234000,
"comment": strategy_name,
"type_time": mt.ORDER_TIME_GTC,
"type_filling": mt.ORDER_FILLING_IOC
}
return mt.order_send(request)
except Exception as e:
print(f"Error in market order: {e}")
return None
print("✅ Helper functions defined (with robust MT5 retry logic)")In [ ]:
def detect_market_regime(df, lookback=50):
"""Market Regime Detection"""
try:
adx_data = ta.adx(df['high'], df['low'], df['close'], length=14)
adx = adx_data['ADX_14'].iloc[-1] if adx_data is not None and 'ADX_14' in adx_data.columns else 25.0
try:
bb = ta.bbands(df['close'], length=20)
if bb is not None and len(bb.columns) >= 3:
bb_cols = bb.columns.tolist()
bb_width = ((bb[bb_cols[0]] - bb[bb_cols[2]]) / bb[bb_cols[1]] * 100).iloc[-lookback:].mean()
else:
bb_width = 4.0
except:
bb_width = 4.0
price_range = df['high'].iloc[-lookback:].max() - df['low'].iloc[-lookback:].min()
atr_avg = df['atr'].iloc[-lookback:].mean()
range_ratio = price_range / (atr_avg * lookback) if atr_avg > 0 else 1.0
vol_cluster = df['atr'].iloc[-10:].std() / df['atr'].iloc[-50:].mean() if len(df) >= 50 else 1.0
if adx > 25 and range_ratio > 1.5:
regime, strength = 'trending', min(100, adx * 2)
elif vol_cluster > 1.5:
regime, strength = 'volatile', min(100, vol_cluster * 50)
else:
regime, strength = 'ranging', max(0, 100 - adx * 2)
return {
'regime': regime, 'strength': strength, 'adx': adx,
'bb_width': bb_width, 'range_ratio': range_ratio, 'vol_cluster': vol_cluster
}
except Exception as e:
return {
'regime': 'ranging', 'strength': 50, 'adx': 20,
'bb_width': 4.0, 'range_ratio': 1.0, 'vol_cluster': 1.0
}
def calculate_adaptive_confidence_threshold_relaxed(regime_info, base_confidence=60):
"""
RELAXED Version: Niedrigere Schwellen für mehr Signale
"""
regime = regime_info['regime']
adx = regime_info['adx']
if regime == 'trending':
if adx > 30:
return max(50, base_confidence - 20)
else:
return base_confidence - 15
elif regime == 'ranging':
return base_confidence + 10
elif regime == 'volatile':
return base_confidence + 15
return base_confidence
def get_enhanced_trend(timeframe="H4", lookback=150, symbol="XAUUSD"):
"""Enhanced Trend Analysis"""
tf_map = {"D1": "d1", "H4": "h4", "H1": "h1", "M30": "m30", "M15": "m15", "M5": "m5"}
tf = tf_map.get(timeframe, timeframe.lower())
try:
df = get_rates(tf, lookback, symbol)
if df is None or len(df) < 50:
return None
df['close_smooth'] = savgol_filter(df['close'], min(15, len(df)//10), 3)
X = np.arange(len(df)).reshape(-1, 1)
y = df['close_smooth'].values
model = LinearRegression().fit(X, y)
slope = model.coef_[0]
regime_info = detect_market_regime(df.iloc[-50:])
base_threshold = df['atr'].iloc[-1] * 0.0001
if regime_info['regime'] == 'trending':
slope_threshold = base_threshold * 0.7
elif regime_info['regime'] == 'ranging':
slope_threshold = base_threshold * 1.5
else:
slope_threshold = base_threshold * 1.2
trend = "uptrend" if slope > slope_threshold else "downtrend" if slope < -slope_threshold else "sideways"
trend_strength = abs(slope) / slope_threshold if slope_threshold > 0 else 0
return {
"trend": trend, "slope": slope, "slope_threshold": slope_threshold,
"trend_strength": trend_strength, "atr": df['atr'].iloc[-1],
"price": df['close'].iloc[-1], "regime_info": regime_info
}
except Exception as e:
print(f"Error in get_enhanced_trend: {e}")
return None
print("✅ Market analysis functions defined (with RELAXED thresholds)")In [ ]:
# ==========================================
# SIMPLIFIED: get_rates now handles retries
# ==========================================
def get_enhanced_trend_with_retry(timeframe, lookback=150, symbol="XAUUSD", max_retries=3):
"""
Wrapper for get_enhanced_trend (retries now in get_rates)
"""
return get_enhanced_trend(timeframe, lookback, symbol)
print("✅ Enhanced trend wrapper ready (retries handled in get_rates)")In [ ]:
def extended_top_down_v2_adaptive(symbol="XAUUSD", lookback=150):
"""
V1.6 Adaptive Complete Version:
- Position Control
- Relaxed Trading Logic
- Adaptive Rhythm Integration
"""
timeframes = ["D1", "H4", "H1", "M30", "M15", "M5"]
trend_info = {}
print(f"🔍 Analyzing {symbol} with V1.6 ADAPTIVE COMPLETE parameters...")
# 1. Alle Timeframes analysieren
for tf in timeframes:
trend_info[tf] = get_enhanced_trend_with_retry(tf, lookback, symbol, max_retries=3)
if trend_info[tf] is None:
print(f"⚠️ Keine Daten für {tf}")
return None
# 2. Market Regime aus H4 bestimmen
main_regime = trend_info["H4"]["regime_info"]
# 3. RELAXED Adaptive Confidence Threshold
adaptive_confidence_threshold = calculate_adaptive_confidence_threshold_relaxed(main_regime)
# 4. Standard-Trend
d1_trend = trend_info["D1"]["trend"]
h4_trend = trend_info["H4"]["trend"]
d1_strength = trend_info["D1"]["trend_strength"]
h4_strength = trend_info["H4"]["trend_strength"]
if d1_trend == h4_trend and d1_trend != "sideways":
standard_trend = d1_trend
standard_strength = (d1_strength * 0.6 + h4_strength * 0.4)
elif d1_strength > h4_strength * 1.5:
standard_trend = d1_trend
standard_strength = d1_strength * 0.8
elif h4_strength > d1_strength * 1.5:
standard_trend = h4_trend
standard_strength = h4_strength * 0.8
else:
standard_trend = "sideways"
standard_strength = 0
# 5. RELAXED Fast-Trend
fast_timeframes = ["H1", "M30", "M15", "M5"]
fast_trends = [trend_info[tf]["trend"] for tf in fast_timeframes]
fast_strengths = [trend_info[tf]["trend_strength"] for tf in fast_timeframes]
required_alignment = 2 # RELAXED: Immer 2 von 4
trend_counts = {'uptrend': 0, 'downtrend': 0, 'sideways': 0}
weighted_strengths = {'uptrend': 0, 'downtrend': 0}
weights = [1.0, 0.8, 0.6, 0.4]
for i, (trend, strength) in enumerate(zip(fast_trends, fast_strengths)):
trend_counts[trend] += 1
if trend != 'sideways':
weighted_strengths[trend] += strength * weights[i]
max_count = max(trend_counts['uptrend'], trend_counts['downtrend'])
if max_count >= required_alignment:
if trend_counts['uptrend'] > trend_counts['downtrend']:
fast_trend = "uptrend"
elif trend_counts['downtrend'] > trend_counts['uptrend']:
fast_trend = "downtrend"
else:
fast_trend = "uptrend" if weighted_strengths['uptrend'] > weighted_strengths['downtrend'] else "downtrend"
else:
fast_trend = "sideways"
# 6. Top-Down-Trend
if standard_trend == fast_trend and standard_trend != "sideways":
top_down_trend = standard_trend
combined_strength = (standard_strength + weighted_strengths.get(fast_trend, 0)) / 2
else:
top_down_trend = "sideways"
combined_strength = 0
# 7. Enhanced Confidence
tf_weights = {"D1": 2.5, "H4": 2.0, "H1": 1.5, "M30": 1.0, "M15": 0.8, "M5": 0.6}
weighted_matching = sum(
tf_weights[tf] * trend_info[tf]["trend_strength"]
for tf in timeframes
if trend_info[tf]["trend"] == top_down_trend and trend_info[tf]["trend"] != "sideways"
)
weighted_total = sum(
tf_weights[tf] * trend_info[tf]["trend_strength"]
for tf in timeframes
if trend_info[tf]["trend"] != "sideways"
)
confidence = round((weighted_matching / weighted_total) * 100, 2) if weighted_total > 0 else 0.0
# 8. RELAXED Risk-Adjusted Signal Strength
atr = trend_info["M5"]["atr"]
rrr = 2.5
risk_adjusted_strength = confidence * combined_strength * min(2.0, rrr)
# 9. RELAXED Entry Signal
entry_signal = 0
signal_quality = "none"
min_strength = 80 # RELAXED: 80 statt 100
if (top_down_trend != "sideways" and
confidence >= adaptive_confidence_threshold and
risk_adjusted_strength >= min_strength):
entry_signal = 1 if top_down_trend == "uptrend" else -1
# RELAXED Signal Quality
if confidence >= 80 and risk_adjusted_strength >= 130:
signal_quality = "excellent"
elif confidence >= 70 and risk_adjusted_strength >= 100:
signal_quality = "good"
else:
signal_quality = "fair"
# 10. 🆕 Adaptive Rhythm Info
current_interval = rhythm_manager.current_interval
session = rhythm_manager.get_current_session()
# 11. Debug Output
debug_data = []
for tf in timeframes:
info = trend_info[tf]
debug_data.append([
tf, info["trend"], f"{info['trend_strength']:.2f}",
f"{info['atr']:.4f}", f"{info['slope']:.6f}", f"{info['price']:.2f}"
])
print(f"\n📊 V1.6 ADAPTIVE COMPLETE Trend-Analyse für {symbol}")
print(f"⚡ Adaptive Interval: {current_interval} min | Session: {session.upper()}")
print(f"🎯 Market Regime: {main_regime['regime'].upper()} (Strength: {main_regime['strength']:.0f}%)")
print(f"🎚️ Adaptive Threshold: {adaptive_confidence_threshold}% (RELAXED)")
print()
print(tabulate(debug_data, headers=["TF", "Trend", "Strength", "ATR", "Slope", "Price"], tablefmt="psql"))
print(f"\n➡️ Standard-Trend: {standard_trend} (Strength: {standard_strength:.2f})")
print(f"➡️ Fast-Trend: {fast_trend} (Required: {required_alignment}/4)")
print(f"➡️ Top-Down-Trend: {top_down_trend}")
print(f"➡️ Confidence: {confidence}% (Threshold: {adaptive_confidence_threshold}%)")
print(f"➡️ Risk-Adjusted Strength: {risk_adjusted_strength:.1f} (Min: {min_strength})")
print(f"➡️ Signal Quality: {signal_quality.upper()}")
print(f"\n🚀 V1.6 Adaptive Complete: Full Features + Adaptive Rhythm")
return {
"symbol": symbol,
"trend_info": trend_info,
"market_regime": main_regime,
"standard_trend": standard_trend,
"fast_trend": fast_trend,
"top_down_trend": top_down_trend,
"confidence": confidence,
"adaptive_threshold": adaptive_confidence_threshold,
"risk_adjusted_strength": risk_adjusted_strength,
"entry_signal": entry_signal,
"signal_quality": signal_quality,
"combined_strength": combined_strength,
"min_strength_used": min_strength,
"required_alignment": required_alignment,
"adaptive_interval": current_interval,
"session": session
}
print("✅ V1.6 Adaptive Complete Top-Down Analysis defined")In [ ]:
def check_pullback_entry(symbol, signal_info, timeframe="M5"):
"""
Entry Timing Check - in Relaxed Version DISABLED per default
"""
if signal_info["entry_signal"] == 0:
return False, "No base signal"
try:
df = get_rates(timeframe.lower(), 50, symbol)
if df is None or len(df) < 20:
return False, "Insufficient data"
df['ema21'] = df['close'].ewm(span=21).mean()
df['ema50'] = df['close'].ewm(span=50).mean()
current_price = df['close'].iloc[-1]
ema21 = df['ema21'].iloc[-1]
ema50 = df['ema50'].iloc[-1]
signal_direction = signal_info["entry_signal"]
if signal_direction == 1: # Long
if current_price <= ema21 * 1.002 and ema21 > ema50:
return True, "Pullback to EMA21 for Long"
elif current_price <= ema21 * 0.998:
return True, "Below EMA21 - Good Long Entry"
elif signal_direction == -1: # Short
if current_price >= ema21 * 0.998 and ema21 < ema50:
return True, "Pullback to EMA21 for Short"
elif current_price >= ema21 * 1.002:
return True, "Above EMA21 - Good Short Entry"
return False, "Waiting for better entry timing"
except Exception as e:
return True, "Using immediate entry (fallback)"
print("✅ Entry timing functions defined (DISABLED in Relaxed mode)")In [ ]:
def calculate_position_size(self, symbol, stop_loss_pips, max_risk_per_trade=None):
"""
Berechnet die Positionsgröße basierend auf Risiko
"""
if max_risk_per_trade is None:
max_risk_per_trade = TRADING_CONFIG["risk"]["max_risk_per_trade"]
account_info = mt.account_info()
if not account_info:
print(f"⚠️ Keine Account-Info verfügbar, verwende Minimum-Lot")
return TRADING_CONFIG["lot_sizing"]["default_lot"]
balance = account_info.balance
risk_amount = balance * max_risk_per_trade
# Symbol-Info holen
symbol_info = mt.symbol_info(symbol)
if not symbol_info:
print(f"⚠️ Keine Symbol-Info für {symbol}, verwende Minimum-Lot")
return TRADING_CONFIG["lot_sizing"]["default_lot"]
# Pip-Wert berechnen
point = symbol_info.point
tick_value = symbol_info.trade_tick_value
tick_size = symbol_info.trade_tick_size
# Volume berechnen
pip_value = (tick_value / tick_size) * point
volume = risk_amount / (stop_loss_pips * pip_value)
# Auf erlaubte Volumenschritte runden
volume_min = symbol_info.volume_min
volume_max = symbol_info.volume_max
volume_step = symbol_info.volume_step
volume = round(volume / volume_step) * volume_step
volume = max(volume_min, min(volume_max, volume))
print(f"💰 Position Sizing für {symbol}:")
print(f" Balance: ${balance:.2f}")
print(f" Risiko: ${risk_amount:.2f} ({max_risk_per_trade*100}%)")
print(f" Stop Loss: {stop_loss_pips:.2f} Pips")
print(f" Berechnetes Volume: {volume:.2f} Lots")
return volumeIn [ ]:
#mt.symbol_info(symbol).volume_min
mt.symbol_info(symbol).volume_stepIn [ ]:
def execute_trade_v2_adaptive(
symbol=None,
atr_mult=None,
base_confidence=None,
max_risk_per_trade=None,
risk_filter=True,
min_atr=0.0008,
use_pullback_entry=False, # DISABLED
max_positions=None,
strategy_name="TradingBot_V1.6",
debug=True,
# Enhanced Scoring Overrides
signal_info_override=None,
confidence_override=None,
# Equity Curve Trading
lot_multiplier=1.0
):
"""
V1.6 Adaptive Complete Trade-Ausführung:
- Position Control
- Relaxed Parameter
- Adaptive Rhythm Integration
"""
# ========================================================================
# LOAD DEFAULTS FROM TRADING_CONFIG
# ========================================================================
if symbol is None:
symbol = TRADING_CONFIG["symbols"]["primary"]
if atr_mult is None:
atr_mult = TRADING_CONFIG["atr"]["base_multiplier"]
if base_confidence is None:
base_confidence = TRADING_CONFIG["confidence"]["base_threshold"]
if max_risk_per_trade is None:
max_risk_per_trade = TRADING_CONFIG["risk"]["max_risk_per_trade"]
if max_positions is None:
max_positions = TRADING_CONFIG["risk"]["max_positions"]
# SCHRITT 1: POSITION CHECK
print(f"\n🔍 POSITION CHECK für {symbol} (V1.6 Adaptive Complete)")
has_position, position_info = check_existing_positions(symbol, strategy_name)
if has_position and position_info['count'] >= max_positions:
if debug:
print(f"🛑 TRADE BLOCKIERT: {position_info['count']}/{max_positions} Positionen aktiv")
for pos in position_info['details']:
profit_emoji = "🟢" if pos['profit'] >= 0 else "🔴"
print(f" {pos['type']} @ {pos['price_open']} | {profit_emoji} {pos['profit']:.2f}")
return None
print(f"✅ Position-Check OK: {position_info['count']}/{max_positions}")
# SCHRITT 2: Signal Analysis (use override if provided)
if signal_info_override is not None:
signal_info = signal_info_override
print("📊 Using pre-calculated signal info (Enhanced Scoring)")
else:
signal_info = extended_top_down_v2_adaptive(symbol)
if signal_info is None:
print("❌ Signal-Analyse fehlgeschlagen")
return None
entry_signal = signal_info["entry_signal"]
# Use override confidence if provided (from Enhanced Scoring)
confidence = confidence_override if confidence_override is not None else signal_info["confidence"]
adaptive_threshold = signal_info["adaptive_threshold"]
signal_quality = signal_info["signal_quality"]
market_regime = signal_info["market_regime"]
# SCHRITT 3: Get Price/ATR
m5_info = signal_info["trend_info"]["M5"]
price = m5_info["price"]
atr = m5_info["atr"]
# SCHRITT 4: Pre-checks
reason = ""
if confidence < adaptive_threshold:
reason = f"Confidence {confidence}% < threshold {adaptive_threshold}%"
elif entry_signal == 0:
reason = f"No entry signal"
elif price is None or atr is None:
reason = "Price/ATR not available"
elif risk_filter and atr < min_atr:
reason = f"ATR {atr:.5f} < min_atr {min_atr}"
else:
risk_ok = check_risk_limits(symbol, max_risk_per_trade=max_risk_per_trade)
if not risk_ok:
reason = "Risk limits exceeded"
# SCHRITT 5: Execute Trade
if not reason:
# Final Position Check
final_check, _ = check_existing_positions(symbol, strategy_name)
if final_check:
print(f"🛑 Position wurde zwischen Checks eröffnet!")
return None
# SL/TP Calculation
regime_mult = 1.0
if market_regime['regime'] == 'volatile':
regime_mult = 1.2
elif market_regime['regime'] == 'ranging':
regime_mult = 0.9
adjusted_atr_mult = atr_mult * regime_mult
if entry_signal == 1: # Long
stop_loss = price - adjusted_atr_mult * atr
take_profit = price + adjusted_atr_mult * atr * 2.5
else: # Short
stop_loss = price + adjusted_atr_mult * atr
take_profit = price - adjusted_atr_mult * atr * 2.5
# Position Sizing
account_info = mt.account_info()
if account_info:
balance = account_info.balance
risk_amount = balance * max_risk_per_trade
if symbol == "XAUUSD":
# 🎯 ADAPTIVE POSITION SIZING
if 'adv_position_mgr' in globals() and adv_position_mgr.adaptive_sizing:
volume = adv_position_mgr.adaptive_sizing.calculate_position_size(
confidence=confidence,
balance=balance,
stop_loss_distance=adjusted_atr_mult * atr * 10000, # Convert to pips
symbol=symbol
)
else:
volume = round(min(TRADING_CONFIG["lot_sizing"]["max_lot"], max(TRADING_CONFIG["lot_sizing"]["min_lot"], risk_amount / (adjusted_atr_mult * atr * 100))),2)
else:
volume = TRADING_CONFIG["lot_sizing"]["default_lot"]
else:
volume = TRADING_CONFIG["lot_sizing"]["default_lot"]
# Apply Equity Curve lot multiplier
if lot_multiplier != 1.0:
original_volume = volume
volume = round(volume * lot_multiplier, 2)
volume = max(TRADING_CONFIG["lot_sizing"]["min_lot"], volume) # Ensure minimum
print(f"📈 Equity Curve: Lot adjusted {original_volume:.2f} → {volume:.2f} ({lot_multiplier:.0%})")
# Log Trade Info
print(f"\n🚀 V1.6 ADAPTIVE COMPLETE TRADE EXECUTION")
print(f"Direction: {'LONG' if entry_signal == 1 else 'SHORT'}")
print(f"Price: {price:.5f} | Volume: {volume:.2f}")
print(f"SL: {stop_loss:.5f} | TP: {take_profit:.5f}")
print(f"Confidence: {confidence}% | Quality: {signal_quality.upper()}")
print(f"Regime: {market_regime['regime'].upper()}")
print(f"Adaptive Interval: {signal_info['adaptive_interval']} min")
print(f"Session: {signal_info['session'].upper()}")
# Execute
try:
order_result = market_order(
symbol=symbol,
volume=volume,
order_type="buy" if entry_signal == 1 else "sell",
stoploss=stop_loss,
take_profit=take_profit
)
if order_result and order_result.retcode == mt.TRADE_RETCODE_DONE:
print(f"✅ Trade erfolgreich! Ticket: {order_result.order}")
# ==========================================
# LOG TRADE ENTRY (V1.8)
# ==========================================
try:
# Hole Position Info
positions = mt.positions_get(symbol=symbol)
if positions and infra:
position = positions[0]
# Erstelle Trade Data
trade_data = {
'ticket': position.ticket,
'position_id': position.identifier,
'symbol': symbol,
'strategy_name': strategy_name,
'type': 'BUY' if entry_signal == 1 else 'SELL',
'volume': volume,
'entry_price': position.price_open,
'sl_price': position.sl,
'tp_price': position.tp,
'entry_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'session': rhythm_manager.get_current_session(),
'regime': market_regime['regime'],
'quality': signal_quality,
'confidence': confidence if 'confidence' in locals() else None,
'timeframe_alignment': signal_info.get('required_alignment', 2),
'risk_amount': risk_amount if 'risk_amount' in locals() else None,
'risk_pct': max_risk_per_trade
}
# Log to Database + Send Telegram
infra.log_trade_entry(trade_data)
logger.info("📱 Trade logged to DB + Telegram notification sent")
except Exception as e:
logger.error(f"⚠️ Infrastructure logging failed: {e}")
# ==========================================
# Verify & Log
new_check, new_info = check_existing_positions(symbol, strategy_name)
print(f"📊 Positionen: {new_info['count']}")
log_trade_performance_adaptive(signal_info, order_result)
else:
print(f"❌ Trade failed: {order_result.comment if order_result else 'No result'}")
return order_result
except Exception as e:
print(f"❌ Execution failed: {e}")
return None
else:
if debug:
print(f"\n⏸️ TRADE SKIPPED: {reason}")
return None
print("✅ V1.6 Adaptive Complete Execute Trade defined")In [ ]:
# ==========================================
# SESSION-SPECIFIC CONFIDENCE FILTER (26.12.2025)
# ==========================================
from session_confidence_filter import create_session_confidence_filter
# Bewahre Original-Funktion (falls noch nicht gespeichert)
if '_original_execute_trade_v2_adaptive' not in dir():
_original_execute_trade_v2_adaptive = execute_trade_v2_adaptive
print("✅ Original execute_trade_v2_adaptive gespeichert")
# Wrap mit Session-Confidence Filter
execute_trade_v2_adaptive = create_session_confidence_filter(
_original_execute_trade_v2_adaptive
)
print("✅ SESSION-SPECIFIC CONFIDENCE FILTER AKTIVIERT")
print("-" * 60)
print("Thresholds:")
print(" Asian: >= 95% Confidence (97.8% WR)")
print(" NY: >= 97% Confidence (verbessert von 43% auf 56% WR)")
print(" London: Blockiert")
print(" Overlap: Blockiert")
print()
print("Erwartete Verbesserung:")
print(" - NY Win-Rate: 43.3% → 56.5%")
print(" - Profit: +$237/Monat in NY Session")
print(" - Gesamt: +$292/Monat")
print("-" * 60)
In [ ]:
# ==========================================
# INSTALL TELEGRAM BOT DEPENDENCIES
# ==========================================
import sys
import subprocess
print("📦 Installing python-telegram-bot...")
try:
# Install or upgrade python-telegram-bot
subprocess.check_call([
sys.executable, "-m", "pip", "install",
"python-telegram-bot", "--upgrade", "--quiet"
])
print("✅ python-telegram-bot installed successfully!")
# Verify
import telegram
print(f"✅ telegram module version: {telegram.__version__}")
except Exception as e:
print(f"❌ Installation failed: {e}")
print("\n⚠️ Please run manually:")
print(" pip install python-telegram-bot --upgrade")
In [ ]:
# ==========================================
# TELEGRAM BOT COMMANDS - Background Service
# ==========================================
from telegram_bot_commands import TelegramBotCommander, get_bot_controller
import threading
# Start Telegram Bot in background
try:
print("🚀 Starting Telegram Bot Commander...")
bot_commander = TelegramBotCommander()
bot_thread = bot_commander.start_background()
# Get controller for integration with execute_trade
bot_controller = get_bot_controller()
print("✅ Telegram Bot is running in background!")
print("📱 Available Commands:")
print(" /status - Bot status & positions")
print(" /pause - Pause trading")
print(" /resume - Resume trading")
print(" /close - Close all positions (requires confirm)")
print(" /balance - Account balance")
print(" /stats - Performance stats")
print(" /help - Show help")
except Exception as e:
print(f"❌ Failed to start Telegram Bot: {e}")
bot_controller = None
In [ ]:
# ==========================================
# NEWS FILTER INTEGRATION
# ==========================================
from news_filter_integration import create_news_filter_wrapper
# Backup original function (if not already backed up)
if '_original_execute_trade_before_news' not in dir():
_original_execute_trade_before_news = execute_trade_v2_adaptive
print("✅ Original execute_trade_v2_adaptive saved")
# Wrap with news filter
execute_trade_v2_adaptive = create_news_filter_wrapper(
_original_execute_trade_before_news
)
print("✅ NEWS FILTER ACTIVATED")
print("-" * 60)
print("Protection: Trading blocked 30min before/after HIGH-IMPACT news")
print("Events monitored:")
print(" • NFP (Non-Farm Payrolls)")
print(" • CPI (Consumer Price Index)")
print(" • FOMC (Fed Interest Rate Decision)")
print(" • Retail Sales, PMI, GDP")
print(" • Other high-impact USD/EUR/GBP events")
print("-" * 60)
print("\n📝 To add events: Edit news_events_manual.json")
print("💡 Recommended: Weekly check ForexFactory calendar")
In [ ]:
# ==========================================
# INTEGRATION: Bot Controller mit execute_trade
# ==========================================
# Original execute_trade_v2_adaptive function wrappen
if 'bot_controller' in dir() and bot_controller is not None:
# Original Funktion sichern
if '_original_execute_trade_before_telegram' not in dir():
_original_execute_trade_before_telegram = execute_trade_v2_adaptive
def execute_trade_with_telegram_control(*args, **kwargs):
"""
Wrapper der bot_controller.is_paused prüft
"""
# Check if trading is paused
if bot_controller.is_paused:
print("⏸️ Trading PAUSED via Telegram")
print(f" Reason: {bot_controller.pause_reason}")
return
# Execute original function
return _original_execute_trade_before_telegram(*args, **kwargs)
# Replace execute_trade
execute_trade_v2_adaptive = execute_trade_with_telegram_control
print("✅ execute_trade_v2_adaptive wrapped with Telegram control")
print(" Trading can now be paused/resumed via /pause and /resume")
else:
print("⚠️ bot_controller not available, skipping integration")
In [ ]:
# ==========================================
# 🔥 FIX #1: RANGING FILTER WRAPPER (09.12.2025)
# ==========================================
# Original function wird wrapped
# [DEAKTIVIERT 20.12.2025] _original_execute_trade_v2_adaptive = execute_trade_v2_adaptive
# [DEAKTIVIERT 20.12.2025] def execute_trade_v2_adaptive_with_ranging_filter(
# [DEAKTIVIERT 20.12.2025] symbol="XAUUSD",
# [DEAKTIVIERT 20.12.2025] atr_mult=1.5,
# [DEAKTIVIERT 20.12.2025] base_confidence=60,
# [DEAKTIVIERT 20.12.2025] max_risk_per_trade=0.01,
# [DEAKTIVIERT 20.12.2025] risk_filter=True,
# [DEAKTIVIERT 20.12.2025] min_atr=0.0008,
# [DEAKTIVIERT 20.12.2025] use_pullback_entry=False,
# [DEAKTIVIERT 20.12.2025] max_positions=1,
# [DEAKTIVIERT 20.12.2025] strategy_name="TradingBot_V1.6",
# [DEAKTIVIERT 20.12.2025] debug=True):
# [DEAKTIVIERT 20.12.2025] """
# [DEAKTIVIERT 20.12.2025] Wrapper für execute_trade_v2_adaptive mit Ranging Filter
# [DEAKTIVIERT 20.12.2025] Blocks trading in ranging markets - they cause 100% of losses!
# [DEAKTIVIERT 20.12.2025] """
# Quick check: Get signal info first
# [DEAKTIVIERT 20.12.2025] signal_info = extended_top_down_v2_adaptive(symbol)
# [DEAKTIVIERT 20.12.2025] if signal_info is None:
# [DEAKTIVIERT 20.12.2025] return None
# [DEAKTIVIERT 20.12.2025] market_regime = signal_info.get("market_regime", {})
# [DEAKTIVIERT 20.12.2025] regime = market_regime.get('regime', 'unknown')
# [DEAKTIVIERT 20.12.2025] adx = market_regime.get('adx', 0)
# 🛑 RANGING FILTER - Block ALL ranging market trades
# [DEAKTIVIERT 20.12.2025] if regime == 'ranging':
# [DEAKTIVIERT 20.12.2025] if debug:
# [DEAKTIVIERT 20.12.2025] print(f"\n🛑 TRADE BLOCKIERT: Ranging Market!")
# [DEAKTIVIERT 20.12.2025] print(f" ADX: {adx:.1f} (< 25 = Ranging)")
# [DEAKTIVIERT 20.12.2025] print(f" 📊 Ranging Performance: 0% Win Rate, 20 consecutive losses")
# [DEAKTIVIERT 20.12.2025] print(f" ✅ Filter is protecting you from losses!")
# [DEAKTIVIERT 20.12.2025] return None
# Additional safety: Even in trending, ADX must be > 25
# [DEAKTIVIERT 20.12.2025] if regime == 'trending' and adx < 25:
# [DEAKTIVIERT 20.12.2025] if debug:
# [DEAKTIVIERT 20.12.2025] print(f"\n🛑 TRADE BLOCKIERT: Weak Trend!")
# [DEAKTIVIERT 20.12.2025] print(f" ADX: {adx:.1f} (< 25 = too weak)")
# [DEAKTIVIERT 20.12.2025] return None
# ✅ Regime check passed - execute original function
# [DEAKTIVIERT 20.12.2025] if debug:
# [DEAKTIVIERT 20.12.2025] print(f"✅ REGIME CHECK PASSED: {regime.upper()} (ADX {adx:.1f})")
# [DEAKTIVIERT 20.12.2025] return _original_execute_trade_v2_adaptive(
# [DEAKTIVIERT 20.12.2025] symbol=symbol,
# [DEAKTIVIERT 20.12.2025] atr_mult=atr_mult,
# [DEAKTIVIERT 20.12.2025] base_confidence=base_confidence,
# [DEAKTIVIERT 20.12.2025] max_risk_per_trade=max_risk_per_trade,
# [DEAKTIVIERT 20.12.2025] risk_filter=risk_filter,
# [DEAKTIVIERT 20.12.2025] min_atr=min_atr,
# [DEAKTIVIERT 20.12.2025] use_pullback_entry=use_pullback_entry,
# [DEAKTIVIERT 20.12.2025] max_positions=max_positions,
# [DEAKTIVIERT 20.12.2025] strategy_name=strategy_name,
# [DEAKTIVIERT 20.12.2025] debug=debug
# [DEAKTIVIERT 20.12.2025] )
# Replace original with wrapped version
# [DEAKTIVIERT 20.12.2025] execute_trade_v2_adaptive = execute_trade_v2_adaptive_with_ranging_filter
# [DEAKTIVIERT 20.12.2025] print("✅ Ranging Filter activated!")
# [DEAKTIVIERT 20.12.2025] print(" 🛑 Blocks ALL ranging market trades")
# [DEAKTIVIERT 20.12.2025] print(" ✅ Only allows trending markets with ADX > 25")
In [ ]:
# ==========================================
# 🎯 MULTI-TIMEFRAME RANGING FILTER (20.12.2025)
# ==========================================
# Verbesserte Ranging-Erkennung basierend auf H1, H4, und D1
from multi_timeframe_regime_filter import create_multi_timeframe_ranging_filter
# Backup der Original-Funktion (falls noch nicht geschehen)
if '_original_execute_trade_v2_adaptive' not in dir():
_original_execute_trade_v2_adaptive = execute_trade_v2_adaptive
# Ersetze mit Multi-TF Filter
execute_trade_v2_adaptive = create_multi_timeframe_ranging_filter(
_original_execute_trade_v2_adaptive
)
print("✅ Multi-Timeframe Ranging Filter aktiviert!")
print(" Prüft: H1, H4, D1")
print(" Gewichtung: D1 (3x) > H4 (2x) > H1 (1x)")
print(" Threshold: ADX > 25")
print("")
print("📊 Entscheidungslogik:")
print(" 1. D1 ADX > 30 → ERLAUBT (starker Trend)")
print(" 2. H4+D1 beide > 25 → ERLAUBT (bestätigter Trend)")
print(" 3. Weighted ADX > 25 → ERLAUBT (Gesamtbild)")
print(" 4. Sonst → BLOCKIERT (Ranging)")
In [ ]:
# ==========================================
# 🧪 TEST: Multi-Timeframe Regime Filter
# ==========================================
# Führe diese Cell aus um den Filter zu testen
from multi_timeframe_regime_filter import detect_multi_timeframe_regime
print("🧪 TESTING MULTI-TIMEFRAME REGIME FILTER")
print("=" * 70)
print()
# Test-Run
result = detect_multi_timeframe_regime("XAUUSD", adx_threshold=25, debug=True)
print()
print("📋 ERGEBNIS:")
print(f" Trading Allowed: {result['allowed']}")
print(f" Regime: {result['regime']}")
print(f" Weighted ADX: {result['weighted_adx']:.1f}")
print()
if result['allowed']:
print("✅ FILTER ERLAUBT TRADES!")
print(" → Bot wird bei nächstem Scheduler-Run traden (wenn andere Bedingungen passen)")
else:
print("🛑 FILTER BLOCKIERT TRADES")
print(f" → Grund: {result['reason']}")
In [ ]:
# ==========================================
# 🔥 FIX #2: POSITION MONITOR DB LOGGING (09.12.2025)
# ==========================================
# Wrap check_open_positions to add DB logging
if 'check_open_positions' in globals():
_original_check_open_positions = check_open_positions
def check_open_positions_with_db_logging():
"""
Enhanced position monitor that writes exits to database
"""
from datetime import datetime
# Get current open positions from MT5
positions = mt.positions_get(symbol=symbol)
if not positions or len(positions) == 0:
# Check if we have positions in DB that should be closed
if 'db' in globals():
try:
open_trades_in_db = db.get_open_trades()
for trade in open_trades_in_db:
ticket = trade['ticket']
# Check if this position is in MT5 history (closed)
deals = mt.history_deals_get(ticket=ticket)
if deals and len(deals) > 0:
# Position was closed - log to DB
last_deal = deals[-1]
db.close_trade(
ticket=ticket,
exit_price=last_deal.price,
exit_time=datetime.fromtimestamp(last_deal.time),
profit=last_deal.profit,
status='closed',
exit_reason='mt5_detected',
commission=last_deal.commission,
swap=last_deal.swap
)
logger.info(f"💾 Position #{ticket} exit logged to DB (profit: ${last_deal.profit:.2f})")
except Exception as e:
logger.error(f"⚠️ DB logging error: {e}")
# Call original function
return _original_check_open_positions()
# Replace
check_open_positions = check_open_positions_with_db_logging
print("✅ Position Monitor DB logging activated!")
print(" 💾 Exits will be written to SQLite database")
print(" 📊 Drawdown Protection will work correctly")
else:
print("⚠️ check_open_positions not found - skipping Position Monitor fix")
In [ ]:
def log_trade_performance_adaptive(signal_info, order_result):
"""
Loggt Trade-Performance für V1.6 Adaptive Complete
"""
trade_data = {
'timestamp': datetime.now().isoformat(),
'version': 'V1.6_Adaptive_Complete',
'symbol': signal_info['symbol'],
'entry_signal': signal_info['entry_signal'],
'confidence': signal_info['confidence'],
'adaptive_threshold': signal_info['adaptive_threshold'],
'signal_quality': signal_info['signal_quality'],
'market_regime': signal_info['market_regime']['regime'],
'regime_strength': signal_info['market_regime']['strength'],
'risk_adjusted_strength': signal_info['risk_adjusted_strength'],
'adaptive_interval': signal_info['adaptive_interval'],
'session': signal_info['session'],
'relaxed_features': {
'pullback_entry_disabled': True,
'lower_confidence_threshold': True,
'lower_min_strength': True,
'fixed_tf_alignment': True
},
'adaptive_features': {
'adaptive_rhythm': True,
'session_aware': True,
'volatility_based': True
},
'position_control_active': True,
'order_result': str(order_result) if order_result else None
}
try:
filename = f"trade_performance_v16_{signal_info['symbol']}_{datetime.now().strftime('%Y%m')}.json"
try:
with open(filename, 'r') as f:
data = json.load(f)
except FileNotFoundError:
data = []
data.append(trade_data)
with open(filename, 'w') as f:
json.dump(data, f, indent=2)
print(f"📊 Performance logged to {filename}")
except Exception as e:
print(f"Warning: Could not log performance: {e}")
def analyze_performance_adaptive(symbol="XAUUSD", days_back=30):
"""
Analysiert Performance der V1.6 Adaptive Complete Version
"""
try:
filename = f"trade_performance_v16_{symbol}_{datetime.now().strftime('%Y%m')}.json"
with open(filename, 'r') as f:
data = json.load(f)
cutoff = datetime.now() - timedelta(days=days_back)
recent_trades = [
trade for trade in data
if datetime.fromisoformat(trade['timestamp']) > cutoff
]
if not recent_trades:
print(f"No V1.6 trades in last {days_back} days")
return
total_trades = len(recent_trades)
# Analysis by regime
by_regime = {}
for trade in recent_trades:
regime = trade['market_regime']
by_regime[regime] = by_regime.get(regime, 0) + 1
# Analysis by interval
by_interval = {}
for trade in recent_trades:
interval = trade.get('adaptive_interval', 'unknown')
by_interval[interval] = by_interval.get(interval, 0) + 1
# Analysis by session
by_session = {}
for trade in recent_trades:
session = trade.get('session', 'unknown')
by_session[session] = by_session.get(session, 0) + 1
# Print results
print(f"\n📊 V1.6 ADAPTIVE COMPLETE PERFORMANCE - Last {days_back} days")
print(f"Total Trades: {total_trades}")
print(f"\nBy Market Regime:")
for regime, count in by_regime.items():
print(f" {regime.upper()}: {count} ({count/total_trades*100:.1f}%)")
print(f"\n🆕 By Adaptive Interval:")
for interval, count in sorted(by_interval.items()):
print(f" {interval} min: {count} ({count/total_trades*100:.1f}%)")
print(f"\n🆕 By Trading Session:")
for session, count in by_session.items():
print(f" {session.upper()}: {count} ({count/total_trades*100:.1f}%)")
except Exception as e:
print(f"Could not analyze performance: {e}")
print("✅ Performance Monitoring functions defined (with adaptive features)")In [ ]:
# ==========================================
# FORCE RESUME TRADING (V2.2 FIX)
# ==========================================
print("🔧 Force resuming trading after Ranging Filter deployment...")
if 'drawdown_protection' in globals():
# Force resume
drawdown_protection._resume_trading()
# Verify
can_trade, reason = drawdown_protection.can_trade()
print(f"\n✅ Status after resume:")
print(f" Can Trade: {can_trade}")
print(f" Reason: {reason if not can_trade else 'All clear!'}")
if not can_trade:
print("\n⚠️ Still blocked - using nuclear option...")
drawdown_protection.trading_paused = False
drawdown_protection.pause_until = None
drawdown_protection.pause_reason = None
can_trade2, reason2 = drawdown_protection.can_trade()
print(f" After force clear: {can_trade2}")
print("\n🛡️ Drawdown Protection Status:")
status = drawdown_protection.get_status()
print(f" Consecutive Losses: {status['consecutive_losses']}")
print(f" Trading Allowed: {status['trading_allowed']}")
else:
print("⚠️ drawdown_protection not initialized yet")In [ ]:
# ==========================================
# TRADING CHECK: SESSION FILTER + DRAWDOWN PROTECTION
# ==========================================
from session_filter_patch import (
create_session_filtered_check,
SESSION_WHITELIST_CONFIG,
is_session_allowed
)
from drawdown_protection import create_protected_trading_check
print("🔧 Setting up Trading Check...")
# Step 1: Create base session-filtered trading check
base_trading_check = create_session_filtered_check(
rhythm_manager=rhythm_manager,
execute_func=execute_trade_v2_adaptive,
symbol=symbol,
strategy_name=strategy_name,
max_positions=max_positions,
logger=logger,
datetime=datetime
)
print("✅ Session Filter aktiviert!")
print(" Deaktivierte Sessions:")
for session, enabled in SESSION_WHITELIST_CONFIG['enabled_sessions'].items():
status = "✅ AKTIV" if enabled else "❌ DEAKTIVIERT"
print(f" • {session.upper():8s}: {status}")
# Step 2: Wrap with Drawdown Protection
adaptive_trading_check = create_protected_trading_check(infra, base_trading_check)
drawdown_protection = adaptive_trading_check.protection
print("\n🛡️ Drawdown Protection aktiviert!")
print(f" • Daily Loss Limit: ${drawdown_protection.max_daily_loss}")
print(f" • Weekly Loss Limit: ${drawdown_protection.max_weekly_loss}")
print(f" • Monthly Loss Limit: ${drawdown_protection.max_monthly_loss}")
print(f" • Max Consecutive Losses: {drawdown_protection.max_consecutive_losses}")
print(f" • Cooldown: {drawdown_protection.cooldown_hours}h")
print("\n✅ Trading Check ist jetzt vollständig geschützt!")
print(" 📊 Session Filter: Aktiv")
print(" 🛡️ Drawdown Protection: Aktiv")
In [ ]:
# Force resume after restart (V2.2 fix)
drawdown_protection._resume_trading()
print("✅ Trading force-resumed (Ranging Filter deployed)")In [ ]:
# def adaptive_trading_check():
# """
# 🆕 V1.6: Adaptive Trading Check
# Prüft basierend auf optimalem Intervall ob gehandelt werden soll
# """
# try:
# optimal_interval = rhythm_manager.calculate_optimal_interval()
# current_minute = datetime.now().minute
# # Trading nur zu berechneten Zeitpunkten
# if current_minute % optimal_interval == 0:
# logger.info(f"\n⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} - ADAPTIVE Check")
# logger.info(f"Intervall: {optimal_interval} min")
# # Führe Trading aus
# execute_trade_v2_adaptive(
# symbol=symbol,
# strategy_name=strategy_name,
# max_positions=max_positions
# )
# except Exception as e:
# logger.error(f"Fehler im Adaptive Trading Check: {e}")
def print_status_report():
"""Status-Report"""
print(rhythm_manager.get_status_report())
# print("✅ Adaptive Scheduler functions defined")In [ ]:
# ============================================================================
# NOTE: This config is DEPRECATED - use TRADING_CONFIG in Cell 6 instead
# This is kept for backward compatibility only
# ============================================================================
# ✅ KORRIGIERT: Zentrale Konfiguration (fehlte in ursprünglicher V1.6)
ADAPTIVE_COMPLETE_CONFIG = {
'symbol': symbol,
'atr_mult': 1.5,
'base_confidence': 60, # RELAXED
'max_risk_per_trade': 0.02,
'risk_filter': True,
'min_atr': 0.0008, # RELAXED
'use_pullback_entry': False, # DISABLED
'max_positions': max_positions,
'strategy_name': strategy_name,
'debug': True
}
print("⚙️ V1.6 Adaptive Complete Configuration:")
print("\n🛡️ Position Control:")
print(f" Max Positions: {ADAPTIVE_COMPLETE_CONFIG['max_positions']}")
print(f" Strategy: {ADAPTIVE_COMPLETE_CONFIG['strategy_name']}")
print("\n🚀 Relaxed Parameters:")
print(f" Base Confidence: {ADAPTIVE_COMPLETE_CONFIG['base_confidence']}%")
print(f" Min ATR: {ADAPTIVE_COMPLETE_CONFIG['min_atr']}")
print(f" Pullback Entry: {ADAPTIVE_COMPLETE_CONFIG['use_pullback_entry']}")
print("\n⚡ Adaptive Features:")
print(f" Dynamic Intervals: 5/15/30 min")
print(f" Session-aware: Yes")
print(f" Volatility-based: Yes")
print("\n✅ Configuration complete!")In [ ]:
# ✅ KORRIGIERT: Umfassendes Status Monitoring (fehlte in V1.6)
def check_adaptive_bot_status():
"""
✅ NEU: Kombiniertes Status-Check für V1.6 Adaptive Complete
Kombiniert Position Control + Adaptive Rhythm Status
"""
print("\n" + "="*70)
print("🔍 V1.6 ADAPTIVE COMPLETE BOT STATUS")
print("="*70)
# System Status
print("\n📡 SYSTEM STATUS:")
print(f" MT5 Connection: {'✅' if mt.terminal_info() else '❌'}")
print(f" Scheduler Running: {'✅' if scheduler.running else '❌'}")
print(f" Active Jobs: {len(scheduler.get_jobs())}")
# Adaptive Rhythm Status
print("\n⚡ ADAPTIVE RHYTHM:")
optimal_interval = rhythm_manager.calculate_optimal_interval()
session = rhythm_manager.get_current_session()
df = rhythm_manager.get_market_data()
if df is not None:
atr = df['atr'].iloc[-1]
vol_level = rhythm_manager.get_volatility_level(atr)
print(f" Current Interval: {optimal_interval} min")
print(f" Trading Session: {session.upper()}")
print(f" ATR (H1): {atr:.2f}")
print(f" Volatility: {vol_level.upper()}")
else:
print(" ⚠️ Could not fetch market data")
# Position Status
print("\n🛡️ POSITION CONTROL:")
has_pos, pos_info = check_existing_positions(symbol, strategy_name)
print(f" Active Positions: {pos_info['count']}/{max_positions}")
print(f" Trading Status: {'🛑 BLOCKED' if has_pos else '✅ READY'}")
if has_pos:
for i, pos in enumerate(pos_info['details'], 1):
profit_emoji = "🟢" if pos['profit'] >= 0 else "🔴"
print(f" Position {i}: {pos['type']} | {profit_emoji} {pos['profit']:.2f}")
# Signal Status
print("\n📊 CURRENT SIGNAL:")
try:
signal_info = extended_top_down_v2_adaptive(symbol)
if signal_info:
signal_dir = "LONG" if signal_info['entry_signal'] == 1 else "SHORT" if signal_info['entry_signal'] == -1 else "NONE"
print(f" Signal: {signal_dir}")
print(f" Confidence: {signal_info['confidence']}%")
print(f" Threshold: {signal_info['adaptive_threshold']}%")
print(f" Quality: {signal_info['signal_quality'].upper()}")
print(f" Regime: {signal_info['market_regime']['regime'].upper()}")
would_trade = (signal_info['entry_signal'] != 0 and not has_pos)
print(f" Would Trade: {'✅ YES' if would_trade else '❌ NO'}")
else:
print(" ⚠️ Signal analysis failed")
except Exception as e:
print(f" ❌ Error: {e}")
# Version Info
print("\n🎉 VERSION INFO:")
print(" Version: V1.6 Adaptive Complete (CORRECTED)")
print(" Features: Position Control + Relaxed + Adaptive Rhythm")
print(" Status: Production-Ready ✅")
print("="*70)
print("✅ Status monitoring function defined (COMPLETE with all features)")In [ ]:
# ==========================================
# SETUP SCHEDULER (V1.6 ADAPTIVE COMPLETE)
# ==========================================
from apscheduler.schedulers.background import BackgroundScheduler
scheduler = BackgroundScheduler()
# 1. ADAPTIVE TRADING CHECK (every minute, executes at optimal intervals)
scheduler.add_job(
func=adaptive_trading_check,
trigger='cron',
minute='*',
id='adaptive_trading_check',
replace_existing=True
)
# 2. STATUS REPORT (every 30 minutes)
scheduler.add_job(
func=print_status_report,
trigger='cron',
minute='0,30',
id='status_report',
replace_existing=True
)
# 3. SCHEDULED REPORTS (V1.8) - Daily & Weekly
create_scheduled_reports(infra, scheduler)
print("✅ Scheduled reports added:")
print(" 📊 Daily report: 22:00 UTC")
print(" 📈 Weekly report: Sunday 23:00 UTC")
# 4. POSITION MONITOR (V1.8) - Every minute
scheduler.add_job(
func=position_monitor.check_open_positions,
trigger='interval',
minutes=1,
id='position_monitor',
replace_existing=True
)
print("✅ Position Monitor job added")
# 5. ADVANCED POSITION MANAGEMENT (V2.1) - Trailing Stop + Partial TP
scheduler.add_job(
func=lambda: adv_position_mgr.check_and_update_positions(symbol),
trigger='interval',
minutes=1,
id='advanced_position_management',
replace_existing=True
)
print("✅ Advanced Position Management job added")
# START SCHEDULER
if not scheduler.running:
scheduler.start()
print("\n✅ Scheduler started!")
else:
print("\n⚠️ Scheduler already running")
# Show active jobs
print(f"\n📋 Active Jobs: {len(scheduler.get_jobs())}")
for job in scheduler.get_jobs():
print(f" • {job.id}")
print("\n" + "="*70)
print("🚀 TradingBot V2.2 - All Systems Ready!")
print("="*70)
In [ ]:
# ✅ KORRIGIERT: Umfassende Testing Suite (fehlte in V1.6)
# Test 1: Position Summary
print("🧪 TEST 1: Position Check")
print("="*50)
get_position_summary(symbol, strategy_name)In [ ]:
# Test 2: Adaptive Rhythm Status
print("\n🧪 TEST 2: Adaptive Rhythm")
print("="*50)
print_status_report()
# Test Details
optimal_interval = rhythm_manager.calculate_optimal_interval()
session = rhythm_manager.get_current_session()
df = rhythm_manager.get_market_data()
if df is not None:
atr = df['atr'].iloc[-1]
vol_level = rhythm_manager.get_volatility_level(atr)
print(f"\nDetails:")
print(f" Optimal Interval: {optimal_interval} min")
print(f" Session: {session}")
print(f" ATR: {atr:.2f}")
print(f" Volatility Level: {vol_level}")In [ ]:
# Test 3: Signal Analysis
print("\n🧪 TEST 3: Signal Analysis")
print("="*50)
signal_result = extended_top_down_v2_adaptive(symbol)
if signal_result:
print(f"\n🎯 SIGNAL SUMMARY:")
print(f" Entry Signal: {signal_result['entry_signal']}")
print(f" Confidence: {signal_result['confidence']}%")
print(f" Threshold: {signal_result['adaptive_threshold']}%")
print(f" Quality: {signal_result['signal_quality'].upper()}")
print(f" Regime: {signal_result['market_regime']['regime'].upper()}")
print(f" Adaptive Interval: {signal_result['adaptive_interval']} min")
print(f" Session: {signal_result['session'].upper()}")
if signal_result['entry_signal'] != 0:
direction = "LONG" if signal_result['entry_signal'] == 1 else "SHORT"
print(f"\n✅ TRADING SIGNAL: {direction}")
else:
print(f"\n⏸️ NO TRADING SIGNAL")
else:
print("❌ Signal analysis failed")In [ ]:
# Test 4: Complete Bot Status
print("\n🧪 TEST 4: Complete Bot Status")
print("="*50)
check_adaptive_bot_status()In [ ]:
# Test 5: Trade Execution Test (DRY RUN)
print("\n🧪 TEST 5: Trade Execution (DRY RUN)")
print("="*50)
print("\nTesting trading logic without actual order...")
# Dies führt die komplette Trading-Logik aus,
# führt aber nur dann wirklich einen Trade aus,
# wenn alle Bedingungen erfüllt sind
test_result = execute_trade_v2_adaptive(**ADAPTIVE_COMPLETE_CONFIG)
if test_result:
print("\n✅ Trade würde ausgeführt!")
else:
print("\n⏸️ Kein Trade - Bedingungen nicht erfüllt")In [ ]:
scheduler.get_jobs()In [ ]:
execute_trade_v2_adaptive(**ADAPTIVE_COMPLETE_CONFIG)In [ ]:
# ✅ KORRIGIERT: Management Control Panel (fehlte in V1.6)
def show_adaptive_management_options():
"""
✅ NEU: Management UI für V1.6 Adaptive Complete
"""
print("\n" + "="*70)
print("🔧 V1.6 ADAPTIVE COMPLETE - MANAGEMENT CONTROL PANEL")
print("="*70)
print("\n📊 MONITORING:")
print(" 1. check_adaptive_bot_status() - Complete Status")
print(" 2. get_position_summary() - Position Overview")
print(" 3. print_status_report() - Adaptive Rhythm Status")
print(" 4. analyze_performance_adaptive() - Performance Analysis")
print("\n🎯 ANALYSIS:")
print(" 5. extended_top_down_v2_adaptive() - Signal Analysis")
print(" 6. rhythm_manager.calculate_optimal_interval() - Current Interval")
print("\n💼 POSITION MANAGEMENT:")
print(" 7. close_existing_positions(force_close=True) - Close All Positions")
print("\n🚀 TRADING:")
print(" 8. execute_trade_v2_adaptive(**ADAPTIVE_COMPLETE_CONFIG) - Manual Trade")
print("\n⚙️ SCHEDULER CONTROL:")
print(" 9. scheduler.get_jobs() - Show Active Jobs")
print(" 10. scheduler.pause() - Pause Scheduler")
print(" 11. scheduler.resume() - Resume Scheduler")
print(" 12. scheduler.shutdown() - Stop Scheduler")
print("\n🔧 CONFIGURATION:")
print(" 13. ADAPTIVE_COMPLETE_CONFIG - View Config")
print(" 14. rhythm_manager.atr_thresholds - ATR Settings")
print("\n📝 QUICK COMMANDS:")
print(" • Status: check_adaptive_bot_status()")
print(" • Close: close_existing_positions(symbol, strategy_name, force_close=True)")
print(" • Stop: scheduler.shutdown()")
print("="*70)
show_adaptive_management_options()In [ ]:
# Optional: Close positions manually
# UNCOMMENT to use:
# close_existing_positions(symbol, strategy_name, force_close=True)
print("💡 To close positions manually, uncomment the code above")In [ ]:
# Optional: ATR-Schwellenwerte anpassen
# UNCOMMENT to use:
# rhythm_manager.atr_thresholds = {
# 'high': 18.0,
# 'medium': 10.0,
# 'low': 5.0
# }
# print("✅ ATR thresholds updated")
print("💡 To adjust ATR thresholds, uncomment the code above")In [ ]:
# Scheduler Control
print("🎛️ SCHEDULER CONTROL")
print("\n💡 To pause trading:")
print("scheduler.pause()")
print("\n💡 To resume trading:")
print("scheduler.resume()")
print("\n💡 To stop completely:")
print("scheduler.shutdown()")
# UNCOMMENT to stop:
# scheduler.shutdown()
# print("🔴 Trading Bot stopped")In [ ]:
print("\n" + "="*70)
print("📈 TRADINGBOT V1.6 ADAPTIVE COMPLETE - SUMMARY")
print("="*70)
print("\n🎉 VERSION: V1.6 ADAPTIVE COMPLETE (CORRECTED & READY!)")
print("\n✅ ALLE FEATURES INTEGRIERT:")
print("\n🛡️ Position Control (aus V1.5):")
print(" • Maximal 1 Trade gleichzeitig")
print(" • check_existing_positions()")
print(" • get_position_summary()")
print(" • close_existing_positions() ✅ KORRIGIERT!")
print("\n🚀 Relaxed Trading Parameters (aus V1.5):")
print(" • 10-20% niedrigere Confidence-Schwellen")
print(" • Disabled Pullback Entry")
print(" • Relaxed Signal-Quality-Filter")
print(" • Niedrigere Min Risk-Adjusted Strength (80)")
print(" • Fixed 2/4 Timeframe Alignment")
print("\n⚡ Adaptive Rhythm (NEU in V1.6):")
print(" • Adaptive Intervalle: 5/15/30 Minuten")
print(" • Volatilitäts-basiert (ATR)")
print(" • Session-abhängig (Asian/London/NY/Overlap)")
print(" • Intelligente Entscheidungs-Matrix")
print("\n📊 Monitoring & Management (aus V1.5, angepasst):")
print(" • Performance Logging")
print(" • Performance Analysis")
print(" • Complete Status Monitoring ✅ KORRIGIERT!")
print(" • Management Control Panel ✅ KORRIGIERT!")
print("\n🤖 Automation:")
print(" • APScheduler Integration")
print(" • Adaptive Trading Checks (jede Minute)")
print(" • Status Reports (alle 30 Min)")
print("\n🧪 Testing Suite (aus V1.5):")
print(" • Position Tests ✅ KORRIGIERT!")
print(" • Signal Analysis Tests ✅ KORRIGIERT!")
print(" • Adaptive Rhythm Tests")
print(" • Complete Status Tests ✅ KORRIGIERT!")
print("\n⚙️ Configuration:")
print(" • ADAPTIVE_COMPLETE_CONFIG ✅ KORRIGIERT!")
print(" • Zentrale Parameter-Verwaltung")
print("\n🎯 VORTEILE VON V1.6 ADAPTIVE COMPLETE:")
print(" ✅ Maximale Sicherheit (Position Control)")
print(" ✅ Maximale Gelegenheiten (Relaxed Parameters)")
print(" ✅ Maximale Effizienz (Adaptive Rhythm)")
print(" ✅ Vollständige Kontrolle (Complete Management)")
print(" ✅ Production-Ready!")
print("\n📊 TYPISCHER 24H-ZYKLUS:")
print(" 00:00-08:00 (Asian) → 15-30 min")
print(" 08:00-13:00 (London) → 5-30 min")
print(" 13:00-16:00 (Overlap) → 5-15 min 🔥")
print(" 16:00-21:00 (NY) → 5-30 min")
print(" 21:00-00:00 (After) → 15-30 min")
print("\n💡 HAUPTFUNKTIONEN:")
print(" • Status: check_adaptive_bot_status()")
print(" • Analyze: extended_top_down_v2_adaptive()")
print(" • Trade: execute_trade_v2_adaptive()")
print(" • Manage: show_adaptive_management_options()")
print("\n🏆 V1.6 ADAPTIVE COMPLETE - ALLE FUNKTIONEN INTEGRIERT!")
print(" 🛡️ Sicherheit + 🚀 Aggressivität + ⚡ Intelligenz")
print(" Production-Ready & Fully Tested! ✅")
print("\n" + "="*70)
print("🎊 Ready for intelligent, safe, and adaptive trading!")
print("="*70)In [ ]:
# Check Drawdown Protection Status
print("🔍 Drawdown Protection Debug:")
print(f" trading_paused: {drawdown_protection.trading_paused}")
print(f" pause_until: {drawdown_protection.pause_until}")
print(f" pause_reason: {drawdown_protection.pause_reason}")
# Force clear everything
drawdown_protection.trading_paused = False
drawdown_protection.pause_until = None
drawdown_protection.pause_reason = None
# Test
can_trade, reason = drawdown_protection.can_trade()
print(f"\n✅ After force clear:")
print(f" Can trade: {can_trade}")
print(f" Reason: {reason}")
# Check consecutive losses in DB
consecutive = drawdown_protection._get_consecutive_losses()
print(f"\n📊 Consecutive losses from DB: {consecutive}")In [ ]:
# # ==========================================
# # RESET CONSECUTIVE LOSSES (V2.2)
# # ==========================================
# from datetime import datetime
# print("🔧 Resetting consecutive losses counter...")
# # Try to find the database instance
# db_instance = None
# if 'db' in globals():
# db_instance = db
# elif 'infra' in globals() and hasattr(infra, 'db'):
# db_instance = infra.db
# print(" Found DB via infra.db")
# elif 'drawdown_protection' in globals() and hasattr(drawdown_protection, 'db'):
# db_instance = drawdown_protection.db
# print(" Found DB via drawdown_protection.db")
# if db_instance:
# try:
# # Insert dummy winning trade directly via SQL
# db_instance.cursor.execute("""
# INSERT INTO trades (
# ticket, symbol, strategy_name, type, volume,
# entry_price, sl_price, tp_price, entry_time,
# session, regime, quality, confidence,
# status, exit_time, profit, net_profit, exit_reason
# ) VALUES (
# 999999999, 'XAUUSD', 'TradingBot_V2.2_Reset', 'BUY', 0.01,
# 2650.00, 2640.00, 2660.00, ?,
# 'manual', 'reset', 'manual_reset', 100.0,
# 'closed', ?, 1.00, 1.00, 'consecutive_loss_reset'
# )
# """, (datetime.now().isoformat(), datetime.now().isoformat()))
# db_instance.conn.commit()
# print("✅ Dummy winning trade inserted!")
# # Check consecutive losses
# consecutive = drawdown_protection._get_consecutive_losses()
# print(f"📊 Consecutive losses after reset: {consecutive}")
# # Clear pause
# drawdown_protection.trading_paused = False
# drawdown_protection.pause_until = None
# drawdown_protection.pause_reason = None
# # Test
# can_trade, reason = drawdown_protection.can_trade()
# print(f"\n✅ FINAL STATUS:")
# print(f" Can trade: {can_trade}")
# print(f" Reason: {reason if not can_trade else 'All systems GO! 🚀'}")
# if can_trade:
# print("\n🎉 SUCCESS! Trading is now ACTIVE!")
# print(" 🛑 Ranging Filter protects you")
# print(" 💾 Exit logging works")
# print(" 📊 Drawdown Protection active")
# else:
# print(f"\n⚠️ Still blocked: {reason}")
# print(" Trying nuclear option...")
# # Override the limit temporarily
# drawdown_protection.max_consecutive_losses = 100
# print(" ✅ Consecutive loss limit raised to 100")
# except Exception as e:
# print(f"❌ Error: {e}")
# import traceback
# traceback.print_exc()
# else:
# print("❌ Could not find database instance!")
# print(" Available globals:", [k for k in globals().keys() if 'db' in k.lower() or 'infra' in k.lower()])In [ ]:
# Prüfe ob Filter aktiv ist
print(SESSION_WHITELIST_CONFIG)
# Teste manuell verschiedene Sessions
for session in ['asian', 'london', 'overlap', 'ny']:
allowed, reason = is_session_allowed(session)
emoji = "✅" if allowed else "❌"
print(f"{emoji} {session}: {reason}")In [ ]:
# Verschiedene Timeframes checken
print("📊 ADX auf verschiedenen Timeframes:\n")
for tf_name, tf in [('M15', mt.TIMEFRAME_M15), ('H1', mt.TIMEFRAME_H1), ('H4', mt.TIMEFRAME_H4), ('D1', mt.TIMEFRAME_D1)]:
rates = mt.copy_rates_from_pos("XAUUSD", tf, 0, 100)
df = pd.DataFrame(rates)
adx_data = ta.adx(df['high'], df['low'], df['close'], length=14)
current_adx = adx_data['ADX_14'].iloc[-1]
# Preis letzte 10 Bars
price_change = ((df['close'].iloc[-1] - df['close'].iloc[-10]) / df['close'].iloc[-10]) * 100
print(f"{tf_name:4s}: ADX = {current_adx:5.2f} | Preis-Change (10 bars): {price_change:+.2f}%")
# Aktueller Preis
print(f"\n💰 Aktueller Preis: {mt.symbol_info_tick('XAUUSD').bid:.2f}")In [ ]:
# Check 1: Base Risk
print(f"Base Risk: {adv_position_mgr.adaptive_sizing.base_risk}")
# Expected: 0.02
# Check 2: Test Volume Calculation
test_vol = adv_position_mgr.adaptive_sizing.calculate_position_size(
confidence=85, balance=10000, stop_loss_distance=50, symbol="XAUUSD"
)
print(f"Test Volume: {test_vol}")
# Expected: >= 0.10 und <= 0.20In [ ]:
# ==========================================
# ADVANCED OPTIMIZATION SETUP (V1.8)
# ==========================================
from dynamic_threshold_optimizer import DynamicThresholdOptimizer, auto_optimize_thresholds
from enhanced_signal_scoring import EnhancedSignalScorer
from enhanced_trailing_stop import EnhancedTrailingStopManager, create_enhanced_position_monitor
from equity_curve_trading import EquityCurveManager
from demo_test_tracker import DemoTestTracker
print("🚀 INITIALIZING ADVANCED OPTIMIZATIONS...")
print("=" * 70)
print()
# 1. Dynamic Threshold Optimizer
threshold_optimizer = DynamicThresholdOptimizer(
db_path="trading_bot.db",
lookback_trades=20, # Letzte 20 Trades analysieren
target_win_rate=0.60, # 60% Ziel Win Rate
min_threshold=60, # Minimum 60% Confidence
max_threshold=95, # Maximum 95% Confidence
adjustment_step=5 # 5% Schritte
)
print("✅ Dynamic Threshold Optimizer initialized")
# 2. Enhanced Signal Scorer
signal_scorer = EnhancedSignalScorer(
weights={
'trend': 0.30, # Existing Trend System
'volume': 0.20, # Volume Analysis
'momentum': 0.20, # RSI + MACD
'support_resistance': 0.15, # S/R Levels
'fibonacci': 0.15 # Fibonacci Levels
}
)
print("✅ Enhanced Signal Scorer initialized")
# 3. Enhanced Trailing Stop
enhanced_trailing = EnhancedTrailingStopManager(
# Early Breakeven (GOLD-OPTIMIERT!)
breakeven_trigger_pct=0.30, # Bei 30% zu TP (früher!)
breakeven_buffer_pips=300, # +$3 über BE (300 × 0.01 für Gold)
# Multi-tier Profit Locking
tier1_trigger=0.50, # Bei 50% → Lock 25%
tier1_lock_pct=0.25,
tier2_trigger=0.75, # Bei 75% → Lock 50%
tier2_lock_pct=0.50,
tier3_trigger=0.90, # Bei 90% → Lock 75%
tier3_lock_pct=0.75,
# ATR-based Trailing (GOLD-OPTIMIERT!)
use_atr_trailing=True,
atr_multiplier=1.5, # 1.5 × ATR für mehr Spielraum
# Time-based Breakeven
time_based_breakeven=True,
hours_to_breakeven=4.0, # Auto-BE nach 4h
# Minimum Distance (GOLD-OPTIMIERT!)
min_distance_points=500, # Min $5 Abstand (500 × 0.01)
# Session-aware Multipliers
session_trailing_multipliers={
'asian': 1.0, # Standard
'ny': 1.5, # Größer (mehr Volatilität)
'london': 1.2,
'overlap': 1.3
}
)
print("✅ Enhanced Trailing Stop Manager initialized")
print()
# 4. Equity Curve Trading
equity_curve_manager = EquityCurveManager(
ma_period=10, # MA über 10 Trades
min_trades_required=5, # Warmup: 5 Trades
soft_mode=True, # Reduzierte Lots statt Stop
soft_mode_multiplier=0.5, # 50% Lots wenn unter MA
recovery_buffer_pct=0.5, # 0.5% über MA = Recovery
data_file="equity_curve_history.json"
)
print("✅ Equity Curve Manager initialized")
print()
# 5. Demo Test Tracker
demo_tracker = DemoTestTracker(
data_file="demo_test_stats.json",
criteria={
'min_trades': 50, # Mindestens 50 Trades
'min_win_rate': 0.55, # 55% Win Rate
'min_profit_factor': 1.3, # Profit Factor > 1.3
'max_drawdown': 0.15, # Max 15% Drawdown
'min_days': 14, # Mindestens 14 Tage
'max_errors': 5, # Max 5 Errors
'min_sessions_tested': 2, # Mindestens 2 Sessions
}
)
print("✅ Demo Test Tracker initialized")
print()
# 4. Run initial threshold optimization
print("🔄 Running initial threshold optimization...")
try:
results = auto_optimize_thresholds(threshold_optimizer, apply_changes=True)
except Exception as e:
print(f"⚠️ Optimization skipped (not enough data): {e}")
print(" Will use default thresholds until 20+ trades collected")
print()
print("=" * 70)
print("🎯 ALL ADVANCED OPTIMIZATIONS ACTIVE!")
print("=" * 70)
print()
print("📊 Summary:")
print(" • Dynamic Thresholds: ✅ (auto-adjusts daily)")
print(" • Enhanced Scoring: ✅ (5-factor analysis)")
print(" • Enhanced Trailing: ✅ (multi-tier protection)")
print(" • Equity Curve Trading: ✅ (auto-pause on drawdown)")
print(" • Demo Test Tracker: ✅ (go-live readiness check)")
print()
print("💡 Tip: Use 'threshold_optimizer.generate_report()' for details")In [ ]:
# ==========================================
# UPDATE SCHEDULER WITH OPTIMIZATIONS
# ==========================================
print("🔄 Updating scheduler with advanced optimizations...")
print()
# 1. Add Daily Threshold Optimization (midnight UTC)
try:
scheduler.remove_job('threshold_optimization')
except:
pass
scheduler.add_job(
func=lambda: auto_optimize_thresholds(threshold_optimizer, apply_changes=True),
trigger='cron',
hour=0, # Midnight UTC
id='threshold_optimization'
)
print("✅ Threshold optimization scheduled (daily at 00:00 UTC)")
# 2. Replace old trailing stop with enhanced version
try:
scheduler.remove_job('advanced_position_management')
print(" Removed old trailing stop")
except:
pass
# Create enhanced monitor
enhanced_monitor = create_enhanced_position_monitor(
enhanced_trailing,
rhythm_manager,
symbol="XAUUSD"
)
scheduler.add_job(
func=enhanced_monitor,
trigger='interval',
minutes=1,
id='enhanced_trailing_stop'
)
print("✅ Enhanced trailing stop scheduled (every 1 min)")
print()
# Print all active jobs
print("📋 Active Scheduler Jobs:")
for job in scheduler.get_jobs():
print(f" • {job.id}: {job.trigger}")
print()
print("✅ Scheduler updated successfully!")In [ ]:
# ==========================================
# TEST: Threshold Optimization Report
# ==========================================
print(threshold_optimizer.generate_report())In [ ]:
# ==========================================
# TEST: Enhanced Signal Scoring
# ==========================================
symbol = "XAUUSD"
# Get base signal
signal_info = extended_top_down_v2_adaptive(symbol)
if signal_info:
price = signal_info['trend_info']['M5']['price']
# Calculate enhanced score
enhanced = signal_scorer.calculate_enhanced_score(
symbol=symbol,
base_confidence=signal_info['confidence'],
trend_direction=signal_info['entry_signal'],
current_price=price
)
print("🎯 ENHANCED SIGNAL TEST")
print("=" * 50)
print(f"Base Confidence: {signal_info['confidence']:.1f}%")
print(f"Enhanced Score: {enhanced.total_score:.1f}%")
print(f"Signal Quality: {enhanced.signal_quality.upper()}")
print(f"Direction: {'LONG' if enhanced.direction == 1 else 'SHORT' if enhanced.direction == -1 else 'NONE'}")
print()
print("📊 Component Breakdown:")
print(f" Trend: {enhanced.trend_score:.1f}/100")
print(f" Volume: {enhanced.volume_score:.1f}/100")
print(f" Momentum: {enhanced.momentum_score:.1f}/100")
print(f" S/R: {enhanced.support_resistance_score:.1f}/100")
print(f" Fibonacci: {enhanced.fibonacci_score:.1f}/100")
print()
print(f"💡 Reason: {enhanced.reason}")
else:
print("❌ No signal available for testing")In [ ]:
# ==========================================
# TEST: Enhanced Trailing Stop Status
# ==========================================
positions = mt.positions_get(symbol="XAUUSD")
if positions:
print("📈 ENHANCED TRAILING STOP STATUS")
print("=" * 50)
for pos in positions:
tier = enhanced_trailing.position_tiers.get(pos.ticket, 0)
# Calculate profit
if pos.type == 0: # BUY
profit_pips = (mt.symbol_info_tick(pos.symbol).bid - pos.price_open) / mt.symbol_info(pos.symbol).point
else: # SELL
profit_pips = (pos.price_open - mt.symbol_info_tick(pos.symbol).ask) / mt.symbol_info(pos.symbol).point
# Calculate progress to TP
if pos.type == 0:
tp_distance = pos.tp - pos.price_open
current_distance = mt.symbol_info_tick(pos.symbol).bid - pos.price_open
else:
tp_distance = pos.price_open - pos.tp
current_distance = pos.price_open - mt.symbol_info_tick(pos.symbol).ask
progress = (current_distance / tp_distance * 100) if tp_distance > 0 else 0
print(f"\nPosition #{pos.ticket}:")
print(f" Type: {'LONG' if pos.type == 0 else 'SHORT'}")
print(f" Entry: {pos.price_open:.2f}")
print(f" Current SL: {pos.sl:.2f}")
print(f" TP: {pos.tp:.2f}")
print(f" Profit: {pos.profit:.2f} USD ({profit_pips:.1f} pips)")
print(f" Progress: {progress:.1f}%")
print(f" Tier: {tier}/3")
# Next tier info
if tier == 0:
print(f" Next: Breakeven @ 30%")
elif tier == 0 and progress >= 30:
print(f" Next: Tier 1 @ 50%")
elif tier == 1:
print(f" Next: Tier 2 @ 75%")
elif tier == 2:
print(f" Next: Tier 3 @ 90%")
else:
print(f" Status: Max protection active!")
else:
print("📭 No open positions")In [ ]:
# ==========================================
# ENHANCED TRADING CHECK WITH SIGNAL SCORING
# ==========================================
def enhanced_trading_check_wrapper(symbol="XAUUSD", debug=False):
"""
Enhanced wrapper around execute_trade_v2_adaptive
Adds multi-factor signal scoring before execution
"""
try:
# SCHRITT 1: Position Check (wie vorher)
max_positions = TRADING_CONFIG['risk']['max_positions']
has_position, position_info = check_existing_positions(symbol)
if position_info['count'] >= max_positions:
if debug:
print(f"🛑 TRADE BLOCKIERT: {position_info['count']}/{max_positions} Positionen aktiv")
for pos in position_info['details']:
profit_emoji = "🟢" if pos['profit'] >= 0 else "🔴"
print(f" {pos['type']} @ {pos['price_open']} | {profit_emoji} {pos['profit']:.2f}")
return None
print(f"✅ Position-Check OK: {position_info['count']}/{max_positions}")
# SCHRITT 1.5: EQUITY CURVE CHECK
ec_allowed, ec_reason, lot_multiplier = equity_curve_manager.should_trade()
print(f"📈 Equity Curve: {ec_reason}")
if not ec_allowed:
print(f"⛔ TRADE BLOCKIERT durch Equity Curve Filter")
return None
# SCHRITT 2: Signal Analysis (wie vorher)
signal_info = extended_top_down_v2_adaptive(symbol)
if signal_info is None:
print("❌ Signal-Analyse fehlgeschlagen")
return None
entry_signal = signal_info["entry_signal"]
base_confidence = signal_info["confidence"]
adaptive_threshold = signal_info["adaptive_threshold"]
print(f"\n📊 Base Signal Analysis:")
print(f" Direction: {entry_signal}")
print(f" Base Confidence: {base_confidence:.1f}%")
print(f" Adaptive Threshold: {adaptive_threshold:.1f}%")
# ⭐ SCHRITT 3: ENHANCED SIGNAL SCORING (HYBRID 60/40)
print(f"\n🎯 Calculating Enhanced Signal Score...")
try:
enhanced = signal_scorer.calculate_enhanced_score(
symbol=symbol,
base_confidence=base_confidence,
trend_direction=entry_signal,
current_price=signal_info['trend_info']['M5']['price']
)
# HYBRID APPROACH: 60% Base Confidence + 40% Enhanced Score
# Das bewährte Trend-System behält Hauptgewicht
enhanced_score = enhanced.total_score
final_confidence = (base_confidence * 0.6) + (enhanced_score * 0.4)
print(f"\n✅ Enhanced Signal Scoring:")
print(f" Trend Score: {enhanced.trend_score:.1f}/100")
print(f" Volume Score: {enhanced.volume_score:.1f}/100")
print(f" Momentum Score: {enhanced.momentum_score:.1f}/100")
print(f" S/R Score: {enhanced.support_resistance_score:.1f}/100")
print(f" Fibonacci Score: {enhanced.fibonacci_score:.1f}/100")
print(f" ─────────────────────────────────────")
print(f" 📊 Base Confidence: {base_confidence:.1f}%")
print(f" 📈 Enhanced Score: {enhanced_score:.1f}%")
print(f" 🔀 HYBRID (60/40): {final_confidence:.1f}%")
print(f" 📈 Signal Quality: {enhanced.signal_quality}")
# Show reasoning
if enhanced.reason:
print(f"\n💡 Analysis: {enhanced.reason}")
except Exception as e:
print(f"⚠️ Enhanced scoring failed: {e}")
print(" Falling back to base confidence")
final_confidence = base_confidence
# SCHRITT 4: Threshold Check
if entry_signal in [1, -1]: # 1=LONG, -1=SHORT
if final_confidence >= adaptive_threshold:
print(f"\n🎯 Signal qualified! {final_confidence:.1f}% >= {adaptive_threshold:.1f}%")
# Execute trade with ENHANCED confidence
# Execute trade with pre-calculated signal_info and enhanced confidence
result = execute_trade_v2_adaptive(
symbol=symbol,
signal_info_override=signal_info,
confidence_override=final_confidence, # ← Use hybrid score!
lot_multiplier=lot_multiplier # ← Equity Curve adjustment
)
# Update Equity Curve nach Trade
if result is not None:
equity_curve_manager.update_equity()
print(f"📈 Equity Curve updated")
return result
else:
print(f"\n❌ Signal below threshold: {final_confidence:.1f}% < {adaptive_threshold:.1f}%")
print(f" Base would have been: {base_confidence:.1f}%")
if final_confidence < base_confidence:
print(f" ⚠️ Enhanced scoring filtered out weak setup!")
return None
else:
print(f"\n⏸️ No clear signal: {entry_signal}")
return None
except Exception as e:
print(f"❌ Enhanced trading check error: {e}")
import traceback
traceback.print_exc()
return None
print("✅ Enhanced trading check wrapper created!")
print(" This will use multi-factor analysis for all trades")
In [ ]:
# ==========================================
# UPDATE SCHEDULER WITH ENHANCED VERSION
# ==========================================
print("🔄 Updating scheduler with enhanced trading check...")
# Remove old job
try:
scheduler.remove_job('adaptive_trading_check')
print(" Removed old adaptive_trading_check job")
except:
pass
# Add enhanced version
scheduler.add_job(
func=lambda: enhanced_trading_check_wrapper("XAUUSD", debug=True),
trigger='interval',
minutes=1,
id='adaptive_trading_check',
name='Enhanced Adaptive Trading Check',
replace_existing=True,
max_instances=1
)
print("\n✅ Enhanced Trading Check activated!")
print(" Scheduler updated with multi-factor signal scoring")
# Show active jobs
print("\n📋 Active Scheduler Jobs:")
for job in scheduler.get_jobs():
print(f" • {job.id}: {job.trigger}")
print("\n" + "=" * 70)
print("🎯 ENHANCED SIGNAL SCORING NOW ACTIVE!")
print("=" * 70)
print("\nBot will now use 5-factor analysis for all trading signals:")
print(" ✅ Trend Alignment (30%)")
print(" ✅ Volume Analysis (20%)")
print(" ✅ Momentum (RSI/MACD) (20%)")
print(" ✅ Support/Resistance (15%)")
print(" ✅ Fibonacci Levels (15%)")
print("\n💡 Expected improvement: +5-10% Win Rate")
print("=" * 70)
In [ ]:
# ==========================================
# TEST ENHANCED SIGNAL SCORING
# ==========================================
print("🧪 Testing Enhanced Signal Scoring...")
print("=" * 70)
# Get current signal
signal_info = extended_top_down_v2_adaptive("XAUUSD")
if signal_info:
base_confidence = signal_info["confidence"]
entry_signal = signal_info["entry_signal"]
print(f"\n📊 Base Signal:")
print(f" Direction: {entry_signal}")
print(f" Confidence: {base_confidence:.1f}%")
# Calculate enhanced score
enhanced = signal_scorer.calculate_enhanced_score(
symbol="XAUUSD",
base_confidence=base_confidence,
trend_direction=entry_signal,
current_price=signal_info['trend_info']['M5']['price']
)
print(f"\n🎯 Enhanced Analysis:")
print(f" Trend: {enhanced.trend_score:.1f}/100 (30%)")
print(f" Volume: {enhanced.volume_score:.1f}/100 (20%)")
print(f" Momentum: {enhanced.momentum_score:.1f}/100 (20%)")
print(f" S/R: {enhanced.support_resistance_score:.1f}/100 (15%)")
print(f" Fibonacci: {enhanced.fibonacci_score:.1f}/100 (15%)")
print(f" ─────────────────────────────────────")
print(f" Total Score: {enhanced.total_score:.1f}%")
print(f" Quality: {enhanced.signal_quality}")
# Compare
diff = enhanced.total_score - base_confidence
if diff > 0:
print(f"\n✅ Enhanced score HIGHER by {diff:.1f}%")
print(f" Setup has strong confirmation factors")
elif diff < 0:
print(f"\n⚠️ Enhanced score LOWER by {abs(diff):.1f}%")
print(f" Setup has weak confirmation factors")
else:
print(f"\n⚪ Enhanced score same as base")
# Show reasoning
if enhanced.reason:
print(f"\n💡 {enhanced.reason}")
else:
print("❌ No signal data available")
print("\n" + "=" * 70)
print("✅ Test complete!")
In [ ]:
# ==========================================
# ENHANCED TRADING CHECK WITH SIGNAL SCORING
# ==========================================
def enhanced_trading_check_wrapper(symbol="XAUUSD", debug=False):
"""
Enhanced wrapper around execute_trade_v2_adaptive
Adds multi-factor signal scoring before execution
"""
try:
# SCHRITT 1: Position Check (wie vorher)
max_positions = TRADING_CONFIG['risk']['max_positions']
has_position, position_info = check_existing_positions(symbol)
if position_info['count'] >= max_positions:
if debug:
print(f"🛑 TRADE BLOCKIERT: {position_info['count']}/{max_positions} Positionen aktiv")
for pos in position_info['details']:
profit_emoji = "🟢" if pos['profit'] >= 0 else "🔴"
print(f" {pos['type']} @ {pos['price_open']} | {profit_emoji} {pos['profit']:.2f}")
return None
print(f"✅ Position-Check OK: {position_info['count']}/{max_positions}")
# SCHRITT 1.5: EQUITY CURVE CHECK
ec_allowed, ec_reason, lot_multiplier = equity_curve_manager.should_trade()
print(f"📈 Equity Curve: {ec_reason}")
if not ec_allowed:
print(f"⛔ TRADE BLOCKIERT durch Equity Curve Filter")
return None
# SCHRITT 2: Signal Analysis (wie vorher)
signal_info = extended_top_down_v2_adaptive(symbol)
if signal_info is None:
print("❌ Signal-Analyse fehlgeschlagen")
return None
entry_signal = signal_info["entry_signal"]
base_confidence = signal_info["confidence"]
adaptive_threshold = signal_info["adaptive_threshold"]
print(f"\n📊 Base Signal Analysis:")
print(f" Direction: {entry_signal}")
print(f" Base Confidence: {base_confidence:.1f}%")
print(f" Adaptive Threshold: {adaptive_threshold:.1f}%")
# ⭐ SCHRITT 3: ENHANCED SIGNAL SCORING (HYBRID 60/40)
print(f"\n🎯 Calculating Enhanced Signal Score...")
try:
enhanced = signal_scorer.calculate_enhanced_score(
symbol=symbol,
base_confidence=base_confidence,
trend_direction=entry_signal,
current_price=signal_info['trend_info']['M5']['price']
)
# HYBRID APPROACH: 60% Base Confidence + 40% Enhanced Score
# Das bewährte Trend-System behält Hauptgewicht
enhanced_score = enhanced.total_score
final_confidence = (base_confidence * 0.6) + (enhanced_score * 0.4)
print(f"\n✅ Enhanced Signal Scoring:")
print(f" Trend Score: {enhanced.trend_score:.1f}/100")
print(f" Volume Score: {enhanced.volume_score:.1f}/100")
print(f" Momentum Score: {enhanced.momentum_score:.1f}/100")
print(f" S/R Score: {enhanced.support_resistance_score:.1f}/100")
print(f" Fibonacci Score: {enhanced.fibonacci_score:.1f}/100")
print(f" ─────────────────────────────────────")
print(f" 📊 Base Confidence: {base_confidence:.1f}%")
print(f" 📈 Enhanced Score: {enhanced_score:.1f}%")
print(f" 🔀 HYBRID (60/40): {final_confidence:.1f}%")
print(f" 📈 Signal Quality: {enhanced.signal_quality}")
# Show reasoning
if enhanced.reason:
print(f"\n💡 Analysis: {enhanced.reason}")
except Exception as e:
print(f"⚠️ Enhanced scoring failed: {e}")
print(" Falling back to base confidence")
final_confidence = base_confidence
# SCHRITT 4: Threshold Check
if entry_signal in [1, -1]: # 1=LONG, -1=SHORT
if final_confidence >= adaptive_threshold:
print(f"\n🎯 Signal qualified! {final_confidence:.1f}% >= {adaptive_threshold:.1f}%")
# Execute trade with ENHANCED confidence
# Execute trade with pre-calculated signal_info and enhanced confidence
result = execute_trade_v2_adaptive(
symbol=symbol,
signal_info_override=signal_info,
confidence_override=final_confidence, # ← Use hybrid score!
lot_multiplier=lot_multiplier # ← Equity Curve adjustment
)
# Update Equity Curve nach Trade
if result is not None:
equity_curve_manager.update_equity()
print(f"📈 Equity Curve updated")
return result
else:
print(f"\n❌ Signal below threshold: {final_confidence:.1f}% < {adaptive_threshold:.1f}%")
print(f" Base would have been: {base_confidence:.1f}%")
if final_confidence < base_confidence:
print(f" ⚠️ Enhanced scoring filtered out weak setup!")
return None
else:
print(f"\n⏸️ No clear signal: {entry_signal}")
return None
except Exception as e:
print(f"❌ Enhanced trading check error: {e}")
import traceback
traceback.print_exc()
return None
print("✅ Enhanced trading check wrapper created!")
print(" This will use multi-factor analysis for all trades")
In [ ]:
# ==========================================
# UPDATE SCHEDULER WITH ENHANCED VERSION
# ==========================================
print("🔄 Updating scheduler with enhanced trading check...")
# Remove old job
try:
scheduler.remove_job('adaptive_trading_check')
print(" Removed old adaptive_trading_check job")
except:
pass
# Add enhanced version
scheduler.add_job(
func=lambda: enhanced_trading_check_wrapper("XAUUSD", debug=True),
trigger='interval',
minutes=1,
id='adaptive_trading_check',
name='Enhanced Adaptive Trading Check',
replace_existing=True,
max_instances=1
)
print("\n✅ Enhanced Trading Check activated!")
print(" Scheduler updated with multi-factor signal scoring")
# Show active jobs
print("\n📋 Active Scheduler Jobs:")
for job in scheduler.get_jobs():
print(f" • {job.id}: {job.trigger}")
print("\n" + "=" * 70)
print("🎯 ENHANCED SIGNAL SCORING NOW ACTIVE!")
print("=" * 70)
print("\nBot will now use 5-factor analysis for all trading signals:")
print(" ✅ Trend Alignment (30%)")
print(" ✅ Volume Analysis (20%)")
print(" ✅ Momentum (RSI/MACD) (20%)")
print(" ✅ Support/Resistance (15%)")
print(" ✅ Fibonacci Levels (15%)")
print("\n💡 Expected improvement: +5-10% Win Rate")
print("=" * 70)
In [ ]:
# ==========================================
# 📊 DEMO TEST TRACKER - REPORTS & GO-LIVE CHECK
# ==========================================
# Führe diese Cell aus um den aktuellen Status zu sehen
print("\n" + "=" * 70)
print("📊 DEMO TEST TRACKER")
print("=" * 70)
# Performance Report
demo_tracker.print_report()
# Go-Live Readiness Check
print("\n")
is_ready = demo_tracker.print_go_live_check()
# Daily Summary
print(demo_tracker.get_daily_summary())
if is_ready:
print("🎉 GRATULATION! Dein Bot ist bereit für echtes Geld!")
print(" Empfehlung: Starte mit 0.01 Lots und beobachte 2 Wochen.")
else:
print("⏳ Weiter testen... Der Bot sammelt noch Daten.")In [ ]:
# ==========================================
# 📊 SYNC MT5 TRADES TO DEMO TRACKER
# ==========================================
# Führe diese Cell aus um geschlossene Trades zu importieren
from datetime import datetime, timedelta
def sync_closed_trades_to_tracker(days_back=7):
"""
Synchronisiert geschlossene Trades aus MT5 History zum Demo Tracker
"""
print("🔄 Syncing closed trades from MT5...")
# Get trade history
from_date = datetime.now() - timedelta(days=days_back)
to_date = datetime.now()
# Get deals (closed trades)
deals = mt.history_deals_get(from_date, to_date)
if deals is None or len(deals) == 0:
print(" No deals found in history")
return 0
# Filter for our strategy
our_deals = [d for d in deals if d.comment and "TradingBot" in d.comment]
# Group by position (entry + exit)
positions = {}
for deal in our_deals:
pos_id = deal.position_id
if pos_id not in positions:
positions[pos_id] = []
positions[pos_id].append(deal)
synced = 0
already_logged = [t['ticket'] for t in demo_tracker.data['trades']]
for pos_id, deals_list in positions.items():
# Need both entry and exit
if len(deals_list) < 2:
continue
entry_deal = None
exit_deal = None
for d in deals_list:
if d.entry == 0: # DEAL_ENTRY_IN
entry_deal = d
elif d.entry == 1: # DEAL_ENTRY_OUT
exit_deal = d
if entry_deal is None or exit_deal is None:
continue
# Skip if already logged
if pos_id in already_logged:
continue
# Determine direction
direction = "LONG" if entry_deal.type == 0 else "SHORT" # 0=BUY, 1=SELL
# Calculate profit
profit = exit_deal.profit + exit_deal.swap + exit_deal.commission
# Determine session (simplified)
hour = datetime.fromtimestamp(entry_deal.time).hour
if 0 <= hour < 8:
session = "asian"
elif 8 <= hour < 13:
session = "london"
elif 13 <= hour < 22:
session = "ny"
else:
session = "asian"
# Log to tracker
demo_tracker.log_trade(
ticket=pos_id,
symbol=entry_deal.symbol,
direction=direction,
entry_price=entry_deal.price,
exit_price=exit_deal.price,
volume=entry_deal.volume,
profit=profit,
entry_time=datetime.fromtimestamp(entry_deal.time),
exit_time=datetime.fromtimestamp(exit_deal.time),
session=session,
base_confidence=0, # Not available from history
enhanced_score=0,
hybrid_score=0,
signal_quality="unknown",
close_reason="history_sync"
)
synced += 1
print(f" ✅ Synced trade #{pos_id}: {direction} {entry_deal.symbol} | Profit: ${profit:.2f}")
print(f"\n📊 Synced {synced} trades to Demo Tracker")
return synced
# Run sync
synced_count = sync_closed_trades_to_tracker(days_back=30)
# Show updated stats
print("\n" + "=" * 50)
stats = demo_tracker.get_stats()
print(f"📊 Total Trades in Tracker: {stats.get('total_trades', 0)}")
print(f"📈 Win Rate: {stats.get('win_rate', 0)*100:.1f}%")
print(f"💰 Total Profit: ${stats.get('total_profit', 0):.2f}")
In [ ]:
# ==========================================
# TEST ENHANCED SIGNAL SCORING
# ==========================================
print("🧪 Testing Enhanced Signal Scoring...")
print("=" * 70)
# Get current signal
signal_info = extended_top_down_v2_adaptive("XAUUSD")
if signal_info:
base_confidence = signal_info["confidence"]
entry_signal = signal_info["entry_signal"]
print(f"\n📊 Base Signal:")
print(f" Direction: {entry_signal}")
print(f" Confidence: {base_confidence:.1f}%")
# Calculate enhanced score
enhanced = signal_scorer.calculate_enhanced_score(
symbol="XAUUSD",
base_confidence=base_confidence,
trend_direction=entry_signal,
current_price=signal_info['trend_info']['M5']['price']
)
print(f"\n🎯 Enhanced Analysis:")
print(f" Trend: {enhanced.trend_score:.1f}/100 (30%)")
print(f" Volume: {enhanced.volume_score:.1f}/100 (20%)")
print(f" Momentum: {enhanced.momentum_score:.1f}/100 (20%)")
print(f" S/R: {enhanced.support_resistance_score:.1f}/100 (15%)")
print(f" Fibonacci: {enhanced.fibonacci_score:.1f}/100 (15%)")
print(f" ─────────────────────────────────────")
print(f" Total Score: {enhanced.total_score:.1f}%")
print(f" Quality: {enhanced.signal_quality}")
# Compare
diff = enhanced.total_score - base_confidence
if diff > 0:
print(f"\n✅ Enhanced score HIGHER by {diff:.1f}%")
print(f" Setup has strong confirmation factors")
elif diff < 0:
print(f"\n⚠️ Enhanced score LOWER by {abs(diff):.1f}%")
print(f" Setup has weak confirmation factors")
else:
print(f"\n⚪ Enhanced score same as base")
# Show reasoning
if enhanced.reason:
print(f"\n💡 {enhanced.reason}")
else:
print("❌ No signal data available")
print("\n" + "=" * 70)
print("✅ Test complete!")
In [ ]:
# ==========================================
# SETUP P&L TRACKER
# ==========================================
from mt5_pnl_tracker import MT5PnLTracker, scheduled_pnl_sync
print("=" * 80)
print("🚀 INITIALIZING P&L TRACKER...")
print("=" * 80)
# Initialize tracker
pnl_tracker = MT5PnLTracker(
db_path="trading_bot.db",
magic_number=None # None = all trades, or specify your EA magic number
)
# Connect to database
pnl_tracker.connect_db()
print("\n✅ P&L Tracker initialized successfully!")
print(" Database: trading_bot.db")
print(" Tables: mt5_deals, matched_positions, pnl_summary")
print("=" * 80)
In [ ]:
# ==========================================
# INITIAL SYNC: IMPORT MT5 HISTORY
# ==========================================
print("\n📥 Importing MT5 history...")
print(" This will import last 30 days of trades from MT5")
print(" Please wait...\n")
# Perform initial sync
sync_results = pnl_tracker.sync_and_update(days_back=30)
if sync_results['success']:
summary = sync_results['summary']
print("=" * 80)
print("✅ SYNC SUCCESSFUL!")
print("=" * 80)
print(f"\n📥 Import Results:")
print(f" New Deals: {summary['new_deals']}")
print(f" Matched Positions: {summary['matched_positions']}")
print(f"\n📊 Current Performance:")
print(f" Total Trades: {summary['total_trades']}")
print(f" Win Rate: {summary['win_rate']:.1f}%")
print(f" Net P&L: ${summary['net_profit']:.2f}")
print("=" * 80)
if summary['new_deals'] == 0:
print("\n💡 No new deals found. This means:")
print(" • History already imported, OR")
print(" • No trades in last 30 days")
else:
print("=" * 80)
print("❌ SYNC FAILED")
print("=" * 80)
print(f"Error: {sync_results.get('error', 'Unknown error')}")
print("\n💡 Troubleshooting:")
print(" • Check MT5 is running")
print(" • Verify MT5 connection")
print(" • Check trading history exists")
In [ ]:
# ==========================================
# ADD P&L SYNC TO SCHEDULER
# ==========================================
from apscheduler.triggers.interval import IntervalTrigger
print("\n🔄 Adding P&L sync to scheduler...")
# Remove old job if exists
try:
scheduler.remove_job('pnl_sync')
print(" Removed old P&L sync job")
except:
pass
# Add hourly P&L sync
scheduler.add_job(
scheduled_pnl_sync,
trigger=IntervalTrigger(hours=1),
args=[pnl_tracker, 7], # Sync last 7 days
id='pnl_sync',
name='P&L Sync',
replace_existing=True,
max_instances=1
)
print("✅ P&L sync scheduled (every 1 hour)")
print(" Syncs last 7 days from MT5")
# Show all scheduler jobs
print("\n📋 Active Scheduler Jobs:")
for job in scheduler.get_jobs():
print(f" • {job.id}: {job.trigger}")
print("\n✅ Scheduler updated successfully!")
print("=" * 80)
Warning:
Output truncated. This notebook contains too many cells to display efficiently.