cbazza/Place-Order-Trading-Bot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7044c19a60f7602da032b521d28949985e84de98
Place-Order-Trading-Bot/TradingBot_V1.6_Adaptive_Complete_CORRECTED.ipynb
T
cbazzaandClaude Opus 4.5 ff23c0b99e
Deploy to Windows VPS / deploy (push) Has been cancelled
Details
fix: Properly escape newlines in Cell 92 using nbformat 
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>
2026-01-27 12:29:58 +01:00

4352 lines
176 KiB
Plaintext
Raw Blame History

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