cbazza/Place-Order-Trading-Bot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
773317f879ff7af6ad2fcb4c6dff7911618d07d8
Place-Order-Trading-Bot/TradingBot_V1.6_Adaptive_Complete_CORRECTED.ipynb
T
cbazzaandClaude Sonnet 4.5 c5937b05ff feat: Activate News Filter with January 2026 events 
- Added 5 high-impact USD news events for January 2026:
  • NFP (Jan 9, 13:30 UTC)
  • CPI (Jan 14, 13:30 UTC)
  • Retail Sales (Jan 15, 13:30 UTC)
  • FOMC Rate Decision (Jan 28, 19:00 UTC)
  • FOMC Press Conference (Jan 28, 19:30 UTC)

- News Filter Cells 31-32 added to notebook
- activate_news_filter.py script created
- Filter blocks trading 30min before/after events
- Expected savings: $400-600/month from avoided news volatility

Status: News Filter READY TO ACTIVATE (run Cell 32)

🤖 Generated with Claude Code

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-01-08 10:19:35 +01:00

3049 lines
161 KiB
Plaintext
Raw Blame History

{
"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": [],
"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": [
"## 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": [
"def get_rates(timeframe=\"h4\", count=200, symbol=\"XAUUSD\"):\n",
" \"\"\"Hole Kursdaten\"\"\"\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",
" try:\n",
" rates = mt.copy_rates_from_pos(symbol, timeframes_dict[timeframe], 0, count)\n",
" if rates is None: \n",
" return None\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",
" print(f\"Error getting rates: {e}\")\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\")"
]
},
{
"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": "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(tf, lookback, symbol)\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=0.02):\n",
" \"\"\"\n",
" Berechnet die Positionsgröße basierend auf Risiko\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 0.01\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 0.01\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=\"XAUUSD\",\n",
" atr_mult=1.5,\n",
" base_confidence=60,\n",
" max_risk_per_trade=0.01,\n",
" risk_filter=True,\n",
" min_atr=0.0008,\n",
" use_pullback_entry=False, # DISABLED\n",
" max_positions=1,\n",
" strategy_name=\"TradingBot_V1.6\",\n",
" debug=True\n",
"):\n",
" \"\"\"\n",
" V1.6 Adaptive Complete Trade-Ausführung:\n",
" - Position Control\n",
" - Relaxed Parameter\n",
" - Adaptive Rhythm Integration\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\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",
" 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\"]\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(0.1, max(0.01, risk_amount / (adjusted_atr_mult * atr * 100))),2)\n",
" else:\n",
" volume = 0.01\n",
" else:\n",
" volume = 0.01\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": "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": [
"# ✅ 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.01,\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": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2026-01-08 09:56:09,047 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:56:12,517 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 09:57:12 CET)\" (scheduled at 2026-01-08 09:56:12.514941+01:00)\n",
"2026-01-08 09:56:12,518 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 09:57:12 CET)\" executed successfully\n",
"2026-01-08 09:56:12,519 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 09:57:12 CET)\" (scheduled at 2026-01-08 09:56:12.515953+01:00)\n",
"2026-01-08 09:56:12,538 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 09:57:12 CET)\" executed successfully\n",
"2026-01-08 09:56:19,067 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:56:29,086 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:56:39,104 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:56:49,148 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:56:59,174 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:57:00,036 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 09:58:00 CET)\" (scheduled at 2026-01-08 09:57:00+01:00)\n",
"2026-01-08 09:57:00,043 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 09:57:00,044 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 09:58:00 CET)\" executed successfully\n",
"2026-01-08 09:57:09,193 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:57:13,090 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 09:58:12 CET)\" (scheduled at 2026-01-08 09:57:12.514941+01:00)\n",
"2026-01-08 09:57:13,092 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 09:58:12 CET)\" executed successfully\n",
"2026-01-08 09:57:13,092 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 09:58:12 CET)\" (scheduled at 2026-01-08 09:57:12.515953+01:00)\n",
"2026-01-08 09:57:13,093 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 09:58:12 CET)\" executed successfully\n",
"2026-01-08 09:57:19,212 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:57:29,248 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:57:39,269 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:57:49,291 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:57:59,311 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:58:00,017 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 09:59:00 CET)\" (scheduled at 2026-01-08 09:58:00+01:00)\n",
"2026-01-08 09:58:00,021 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 09:58:00,022 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 09:59:00 CET)\" executed successfully\n",
"2026-01-08 09:58:09,331 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:58:12,556 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 09:59:12 CET)\" (scheduled at 2026-01-08 09:58:12.514941+01:00)\n",
"2026-01-08 09:58:12,561 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 09:59:12 CET)\" (scheduled at 2026-01-08 09:58:12.515953+01:00)\n",
"2026-01-08 09:58:12,671 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 09:59:12 CET)\" executed successfully\n",
"2026-01-08 09:58:12,671 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 09:59:12 CET)\" executed successfully\n",
"2026-01-08 09:58:19,351 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:58:29,385 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:58:39,406 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:58:49,419 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:58:59,447 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:59:01,213 - WARNING - Run time of job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:00:00 CET)\" was missed by 0:00:01.213237\n",
"2026-01-08 09:59:09,470 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:59:12,532 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:00:12 CET)\" (scheduled at 2026-01-08 09:59:12.514941+01:00)\n",
"2026-01-08 09:59:12,534 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:00:12 CET)\" executed successfully\n",
"2026-01-08 09:59:12,534 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:00:12 CET)\" (scheduled at 2026-01-08 09:59:12.515953+01:00)\n",
"2026-01-08 09:59:12,535 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:00:12 CET)\" executed successfully\n",
"2026-01-08 09:59:19,489 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:59:29,509 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:59:39,528 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:59:49,547 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 09:59:59,568 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:00:00,078 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:01:00 CET)\" (scheduled at 2026-01-08 10:00:00+01:00)\n",
"2026-01-08 10:00:00,081 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:00:00,083 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:01:00 CET)\" executed successfully\n",
"2026-01-08 10:00:00,084 - INFO - Running job \"print_status_report (trigger: cron[minute='0,30'], next run at: 2026-01-08 10:30:00 CET)\" (scheduled at 2026-01-08 10:00:00+01:00)\n",
"2026-01-08 10:00:01,127 - INFO - Job \"print_status_report (trigger: cron[minute='0,30'], next run at: 2026-01-08 10:30:00 CET)\" executed successfully\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"╔════════════════════════════════════════════════════════╗\n",
"║ ADAPTIVE RHYTHM STATUS - 10:00:01 UTC ║\n",
"╠════════════════════════════════════════════════════════╣\n",
"║ Aktuelles Intervall: 15 Minuten ║\n",
"║ Trading Session: LONDON ║\n",
"║ Volatilitätslevel: MEDIUM ║\n",
"║ ATR (H1): 14.13 ║\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"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2026-01-08 10:00:09,589 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:00:12,534 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:01:12 CET)\" (scheduled at 2026-01-08 10:00:12.514941+01:00)\n",
"2026-01-08 10:00:12,535 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:01:12 CET)\" (scheduled at 2026-01-08 10:00:12.515953+01:00)\n",
"2026-01-08 10:00:12,537 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:01:12 CET)\" executed successfully\n",
"2026-01-08 10:00:12,542 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:01:12 CET)\" executed successfully\n",
"2026-01-08 10:00:19,614 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:00:29,627 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:00:39,654 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:00:49,675 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:00:59,696 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:01:00,052 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:02:00 CET)\" (scheduled at 2026-01-08 10:01:00+01:00)\n",
"2026-01-08 10:01:00,055 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:01:00,055 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:02:00 CET)\" executed successfully\n",
"2026-01-08 10:01:09,715 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:01:12,606 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:02:12 CET)\" (scheduled at 2026-01-08 10:01:12.514941+01:00)\n",
"2026-01-08 10:01:12,639 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:02:12 CET)\" executed successfully\n",
"2026-01-08 10:01:12,616 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:02:12 CET)\" (scheduled at 2026-01-08 10:01:12.515953+01:00)\n",
"2026-01-08 10:01:12,675 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:02:12 CET)\" executed successfully\n",
"2026-01-08 10:01:19,746 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:01:29,765 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:01:39,798 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:01:49,828 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:01:59,849 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:02:00,085 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:03:00 CET)\" (scheduled at 2026-01-08 10:02:00+01:00)\n",
"2026-01-08 10:02:00,101 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:02:00,103 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:03:00 CET)\" executed successfully\n",
"2026-01-08 10:02:09,869 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:02:12,595 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:03:12 CET)\" (scheduled at 2026-01-08 10:02:12.514941+01:00)\n",
"2026-01-08 10:02:12,600 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:03:12 CET)\" executed successfully\n",
"2026-01-08 10:02:12,597 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:03:12 CET)\" (scheduled at 2026-01-08 10:02:12.515953+01:00)\n",
"2026-01-08 10:02:12,780 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:03:12 CET)\" executed successfully\n",
"2026-01-08 10:02:19,892 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:02:29,912 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:02:39,930 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:02:49,952 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:02:59,970 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:03:00,203 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:04:00 CET)\" (scheduled at 2026-01-08 10:03:00+01:00)\n",
"2026-01-08 10:03:00,229 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:03:00,230 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:04:00 CET)\" executed successfully\n",
"2026-01-08 10:03:09,988 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:03:12,686 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:04:12 CET)\" (scheduled at 2026-01-08 10:03:12.514941+01:00)\n",
"2026-01-08 10:03:12,688 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:04:12 CET)\" executed successfully\n",
"2026-01-08 10:03:12,689 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:04:12 CET)\" (scheduled at 2026-01-08 10:03:12.515953+01:00)\n",
"2026-01-08 10:03:12,701 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:04:12 CET)\" executed successfully\n",
"2026-01-08 10:03:20,010 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:03:30,026 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:03:40,051 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:03:50,070 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:04:00,023 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:05:00 CET)\" (scheduled at 2026-01-08 10:04:00+01:00)\n",
"2026-01-08 10:04:00,034 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:04:00,036 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:05:00 CET)\" executed successfully\n",
"2026-01-08 10:04:00,111 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:04:10,144 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:04:12,563 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:05:12 CET)\" (scheduled at 2026-01-08 10:04:12.514941+01:00)\n",
"2026-01-08 10:04:12,565 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:05:12 CET)\" executed successfully\n",
"2026-01-08 10:04:12,566 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:05:12 CET)\" (scheduled at 2026-01-08 10:04:12.515953+01:00)\n",
"2026-01-08 10:04:12,568 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:05:12 CET)\" executed successfully\n",
"2026-01-08 10:04:20,166 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:04:30,189 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:04:40,915 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:04:50,949 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:05:00,215 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:06:00 CET)\" (scheduled at 2026-01-08 10:05:00+01:00)\n",
"2026-01-08 10:05:00,221 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:05:00,222 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:06:00 CET)\" executed successfully\n",
"2026-01-08 10:05:00,987 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:05:11,014 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:05:12,531 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:06:12 CET)\" (scheduled at 2026-01-08 10:05:12.514941+01:00)\n",
"2026-01-08 10:05:12,531 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:06:12 CET)\" (scheduled at 2026-01-08 10:05:12.515953+01:00)\n",
"2026-01-08 10:05:12,534 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:06:12 CET)\" executed successfully\n",
"2026-01-08 10:05:12,533 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:06:12 CET)\" executed successfully\n",
"2026-01-08 10:05:21,042 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:05:31,068 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:05:41,097 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:05:51,124 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:06:00,011 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:07:00 CET)\" (scheduled at 2026-01-08 10:06:00+01:00)\n",
"2026-01-08 10:06:00,069 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:06:00,070 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:07:00 CET)\" executed successfully\n",
"2026-01-08 10:06:01,152 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:06:11,266 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:06:12,597 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:07:12 CET)\" (scheduled at 2026-01-08 10:06:12.514941+01:00)\n",
"2026-01-08 10:06:12,599 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:07:12 CET)\" executed successfully\n",
"2026-01-08 10:06:12,600 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:07:12 CET)\" (scheduled at 2026-01-08 10:06:12.515953+01:00)\n",
"2026-01-08 10:06:12,600 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:07:12 CET)\" executed successfully\n",
"2026-01-08 10:06:21,302 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:06:31,327 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:06:41,354 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:06:51,386 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:07:00,001 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:08:00 CET)\" (scheduled at 2026-01-08 10:07:00+01:00)\n",
"2026-01-08 10:07:00,004 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:07:00,006 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:08:00 CET)\" executed successfully\n",
"2026-01-08 10:07:01,410 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:07:11,434 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:07:12,895 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:08:12 CET)\" (scheduled at 2026-01-08 10:07:12.514941+01:00)\n",
"2026-01-08 10:07:12,897 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:08:12 CET)\" executed successfully\n",
"2026-01-08 10:07:12,895 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:08:12 CET)\" (scheduled at 2026-01-08 10:07:12.515953+01:00)\n",
"2026-01-08 10:07:12,913 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:08:12 CET)\" executed successfully\n",
"2026-01-08 10:07:21,462 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:07:31,492 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:07:41,522 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:07:51,548 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:08:00,011 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:09:00 CET)\" (scheduled at 2026-01-08 10:08:00+01:00)\n",
"2026-01-08 10:08:00,015 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:08:00,017 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:09:00 CET)\" executed successfully\n",
"2026-01-08 10:08:01,594 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:08:11,623 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:08:12,542 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:09:12 CET)\" (scheduled at 2026-01-08 10:08:12.514941+01:00)\n",
"2026-01-08 10:08:12,543 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:09:12 CET)\" (scheduled at 2026-01-08 10:08:12.515953+01:00)\n",
"2026-01-08 10:08:12,546 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:09:12 CET)\" executed successfully\n",
"2026-01-08 10:08:12,545 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:09:12 CET)\" executed successfully\n",
"2026-01-08 10:08:21,648 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:08:31,686 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:08:41,714 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:08:51,745 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:09:00,004 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:10:00 CET)\" (scheduled at 2026-01-08 10:09:00+01:00)\n",
"2026-01-08 10:09:00,008 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:09:00,009 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:10:00 CET)\" executed successfully\n",
"2026-01-08 10:09:01,771 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:09:11,800 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:09:12,801 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:10:12 CET)\" (scheduled at 2026-01-08 10:09:12.514941+01:00)\n",
"2026-01-08 10:09:12,801 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:10:12 CET)\" (scheduled at 2026-01-08 10:09:12.515953+01:00)\n",
"2026-01-08 10:09:12,803 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:10:12 CET)\" executed successfully\n",
"2026-01-08 10:09:12,804 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:10:12 CET)\" executed successfully\n",
"2026-01-08 10:09:21,830 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:09:31,879 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:09:41,912 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:09:51,939 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:10:00,002 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:11:00 CET)\" (scheduled at 2026-01-08 10:10:00+01:00)\n",
"2026-01-08 10:10:00,071 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:10:00,148 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:11:00 CET)\" executed successfully\n",
"2026-01-08 10:10:01,972 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:10:11,998 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:10:12,515 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:11:12 CET)\" (scheduled at 2026-01-08 10:10:12.514941+01:00)\n",
"2026-01-08 10:10:12,516 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:11:12 CET)\" executed successfully\n",
"2026-01-08 10:10:12,610 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:11:12 CET)\" (scheduled at 2026-01-08 10:10:12.515953+01:00)\n",
"2026-01-08 10:10:12,612 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:11:12 CET)\" executed successfully\n",
"2026-01-08 10:10:22,024 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:10:32,052 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:10:42,078 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:10:52,109 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:11:00,001 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:12:00 CET)\" (scheduled at 2026-01-08 10:11:00+01:00)\n",
"2026-01-08 10:11:00,004 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:11:00,005 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:12:00 CET)\" executed successfully\n",
"2026-01-08 10:11:02,133 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:11:12,162 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:11:12,531 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:12:12 CET)\" (scheduled at 2026-01-08 10:11:12.514941+01:00)\n",
"2026-01-08 10:11:12,532 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:12:12 CET)\" executed successfully\n",
"2026-01-08 10:11:12,533 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:12:12 CET)\" (scheduled at 2026-01-08 10:11:12.515953+01:00)\n",
"2026-01-08 10:11:12,544 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:12:12 CET)\" executed successfully\n",
"2026-01-08 10:11:22,189 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:11:32,215 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:11:42,243 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:11:52,268 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:12:00,021 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:13:00 CET)\" (scheduled at 2026-01-08 10:12:00+01:00)\n",
"2026-01-08 10:12:00,045 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:12:00,060 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:13:00 CET)\" executed successfully\n",
"2026-01-08 10:12:02,292 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:12:12,318 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:12:12,582 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:13:12 CET)\" (scheduled at 2026-01-08 10:12:12.514941+01:00)\n",
"2026-01-08 10:12:12,583 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:13:12 CET)\" (scheduled at 2026-01-08 10:12:12.515953+01:00)\n",
"2026-01-08 10:12:12,590 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:13:12 CET)\" executed successfully\n",
"2026-01-08 10:12:12,585 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:13:12 CET)\" executed successfully\n",
"2026-01-08 10:12:22,344 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:12:32,371 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:12:42,397 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:12:52,421 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:13:00,000 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:14:00 CET)\" (scheduled at 2026-01-08 10:13:00+01:00)\n",
"2026-01-08 10:13:00,006 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:13:00,008 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:14:00 CET)\" executed successfully\n",
"2026-01-08 10:13:02,450 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:13:12,479 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:13:12,556 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:14:12 CET)\" (scheduled at 2026-01-08 10:13:12.514941+01:00)\n",
"2026-01-08 10:13:12,558 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:14:12 CET)\" executed successfully\n",
"2026-01-08 10:13:12,559 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:14:12 CET)\" (scheduled at 2026-01-08 10:13:12.515953+01:00)\n",
"2026-01-08 10:13:12,567 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:14:12 CET)\" executed successfully\n",
"2026-01-08 10:13:22,506 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:13:32,533 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:13:42,559 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:13:52,592 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:14:00,052 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:15:00 CET)\" (scheduled at 2026-01-08 10:14:00+01:00)\n",
"2026-01-08 10:14:00,054 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:14:00,056 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:15:00 CET)\" executed successfully\n",
"2026-01-08 10:14:02,618 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:14:12,530 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:15:12 CET)\" (scheduled at 2026-01-08 10:14:12.514941+01:00)\n",
"2026-01-08 10:14:12,532 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:15:12 CET)\" executed successfully\n",
"2026-01-08 10:14:12,533 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:15:12 CET)\" (scheduled at 2026-01-08 10:14:12.515953+01:00)\n",
"2026-01-08 10:14:12,534 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:15:12 CET)\" executed successfully\n",
"2026-01-08 10:14:12,658 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:14:22,689 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:14:32,724 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:14:42,751 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:14:52,786 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:15:00,049 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:16:00 CET)\" (scheduled at 2026-01-08 10:15:00+01:00)\n",
"2026-01-08 10:15:00,061 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:15:00,063 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:16:00 CET)\" executed successfully\n",
"2026-01-08 10:15:02,809 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:15:12,536 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:16:12 CET)\" (scheduled at 2026-01-08 10:15:12.514941+01:00)\n",
"2026-01-08 10:15:12,536 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:16:12 CET)\" (scheduled at 2026-01-08 10:15:12.515953+01:00)\n",
"2026-01-08 10:15:12,549 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:16:12 CET)\" executed successfully\n",
"2026-01-08 10:15:12,549 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:16:12 CET)\" executed successfully\n",
"2026-01-08 10:15:12,835 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:15:22,861 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:15:32,887 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:15:42,924 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:15:52,949 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:16:00,023 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:17:00 CET)\" (scheduled at 2026-01-08 10:16:00+01:00)\n",
"2026-01-08 10:16:00,083 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:16:00,084 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:17:00 CET)\" executed successfully\n",
"2026-01-08 10:16:02,974 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:16:12,688 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:17:12 CET)\" (scheduled at 2026-01-08 10:16:12.514941+01:00)\n",
"2026-01-08 10:16:12,690 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:17:12 CET)\" executed successfully\n",
"2026-01-08 10:16:12,691 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:17:12 CET)\" (scheduled at 2026-01-08 10:16:12.515953+01:00)\n",
"2026-01-08 10:16:12,693 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:17:12 CET)\" executed successfully\n",
"2026-01-08 10:16:13,002 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:16:23,029 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:16:33,057 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:16:43,085 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:16:53,120 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:17:00,110 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:18:00 CET)\" (scheduled at 2026-01-08 10:17:00+01:00)\n",
"2026-01-08 10:17:00,113 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:17:00,117 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:18:00 CET)\" executed successfully\n",
"2026-01-08 10:17:03,155 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:17:12,515 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:18:12 CET)\" (scheduled at 2026-01-08 10:17:12.514941+01:00)\n",
"2026-01-08 10:17:12,517 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:18:12 CET)\" executed successfully\n",
"2026-01-08 10:17:12,536 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:18:12 CET)\" (scheduled at 2026-01-08 10:17:12.515953+01:00)\n",
"2026-01-08 10:17:12,538 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:18:12 CET)\" executed successfully\n",
"2026-01-08 10:17:13,181 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:17:23,207 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:17:33,234 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:17:43,260 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:17:53,285 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:18:00,044 - INFO - Running job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:19:00 CET)\" (scheduled at 2026-01-08 10:18:00+01:00)\n",
"2026-01-08 10:18:00,063 - INFO - ⏸️ Trading SKIP: London blocked: 12.5% win-rate, -$10/trade\n",
"2026-01-08 10:18:00,065 - INFO - Job \"create_protected_trading_check.<locals>.protected_check (trigger: cron[minute='*'], next run at: 2026-01-08 10:19:00 CET)\" executed successfully\n",
"2026-01-08 10:18:03,313 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:18:12,676 - INFO - Running job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:19:12 CET)\" (scheduled at 2026-01-08 10:18:12.514941+01:00)\n",
"2026-01-08 10:18:12,677 - INFO - Running job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:19:12 CET)\" (scheduled at 2026-01-08 10:18:12.515953+01:00)\n",
"2026-01-08 10:18:12,684 - INFO - Job \"<lambda> (trigger: interval[0:01:00], next run at: 2026-01-08 10:19:12 CET)\" executed successfully\n",
"2026-01-08 10:18:12,680 - INFO - Job \"PositionMonitor.check_open_positions (trigger: interval[0:01:00], next run at: 2026-01-08 10:19:12 CET)\" executed successfully\n",
"2026-01-08 10:18:13,342 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:18:23,366 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:18:33,416 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n",
"2026-01-08 10:18:43,441 - INFO - HTTP Request: POST https://api.telegram.org/bot7783303065:AAHVVvwWGqmhJ2BVq8LqkLRSsicKy1CUsD8/getUpdates \"HTTP/1.1 200 OK\"\n"
]
}
],
"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": []
}
],
"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