provide more detailed implementation, security best practices, or discuss advanced alert…
- User
provide more detailed implementation, security best practices, or discuss advanced alert strategies
Assistant
Comprehensive Telegram Alert System for Trading Strategies
1. Detailed Implementation
Core Alert System Architecture
import telebot import os import logging import json import time from dotenv import load_dotenv from datetime import datetime from threading import Lock from functools import wraps # Configure logging logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler("telegram_alerts.log"), logging.StreamHandler() ] ) logger = logging.getLogger("TelegramAlerts") # Load environment variables load_dotenv() TELEGRAM_BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN') TELEGRAM_CHAT_ID = os.getenv('TELEGRAM_CHAT_ID') ADMIN_CHAT_ID = os.getenv('ADMIN_CHAT_ID') class RateLimiter: """Rate limiting to prevent spam""" def __init__(self, max_calls=5, time_frame=60): self.max_calls = max_calls self.time_frame = time_frame # in seconds self.calls = [] self.lock = Lock() def __call__(self, func): @wraps(func) def wrapped(*args, **kwargs): with self.lock: now = time.time() # Remove old calls self.calls = [call for call in self.calls if call > now - self.time_frame] if len(self.calls) >= self.max_calls: logger.warning(f"Rate limit exceeded for {func.__name__}") return None self.calls.append(now) return func(*args, **kwargs) return wrapped class TelegramAlertSystem: def __init__(self): self.bot = telebot.TeleBot(TELEGRAM_BOT_TOKEN) self.message_queue = [] self.last_error_time = 0 self.error_count = 0 # Initialize command handlers self.setup_command_handlers() def setup_command_handlers(self): """Set up bot command handlers""" @self.bot.message_handler(commands=['status']) def handle_status(message): if str(message.chat.id) in [TELEGRAM_CHAT_ID, ADMIN_CHAT_ID]: self.bot.reply_to(message, "Trading system is operational ✅") @self.bot.message_handler(commands=['performance']) def handle_performance(message): if str(message.chat.id) in [TELEGRAM_CHAT_ID, ADMIN_CHAT_ID]: # Get performance data from trading system performance = self.get_performance_data() self.bot.reply_to(message, performance) def get_performance_data(self): """Get performance data from trading system""" # This would connect to your trading system's database # Placeholder for demonstration return """ 📊 Performance Summary: Win Rate: 92.5% Total Trades: 40 Profit: $1,250 """ @RateLimiter(max_calls=5, time_frame=60) def send_trade_alert(self, signal): """Send detailed trade alerts with rate limiting""" # Format timestamp timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Calculate confidence score based on indicator agreement confidence_score = self._calculate_confidence(signal) confidence_emoji = "🟢" if confidence_score > 80 else "🟡" if confidence_score > 60 else "🔴" message = f""" 🚨 *WEALTH WARRIOR TRADE ALERT* 🚨 {confidence_emoji} Confidence: {confidence_score}% 📊 Asset: {signal['asset']} 📈 Direction: {signal['direction']} 💰 Entry Price: {signal['entry_price']} ⏰ Timeframe: {signal['timeframe']} ⌚ Time: {timestamp} Indicators: - EMA Trend: {'Bullish ↗️' if signal['ema_trend'] else 'Bearish ↘️'} - RSI: {signal['rsi_value']} {'(Oversold)' if signal['rsi_value'] < 30 else '(Overbought)' if signal['rsi_value'] > 70 else ''} - MACD: {signal['macd_status']} Risk Management: - Position Size: {signal['position_size']}% - Stop Loss: {signal['stop_loss']} - Take Profit: {signal['take_profit']} Expected Outcome: - Win Probability: {signal.get('win_probability', 'N/A')}% - Risk/Reward: {signal.get('risk_reward', 'N/A')} """ # Add chart image if available chart_path = signal.get('chart_path') try: if chart_path and os.path.exists(chart_path): with open(chart_path, 'rb') as chart: self.bot.send_photo( TELEGRAM_CHAT_ID, chart, caption=message, parse_mode='Markdown' ) else: self.bot.send_message( TELEGRAM_CHAT_ID, message, parse_mode='Markdown' ) # Log successful alert logger.info(f"Trade alert sent for {signal['asset']}") # Reset error counter on success self.error_count = 0 except Exception as e: self._handle_send_error(e, message) def _calculate_confidence(self, signal): """Calculate confidence score based on indicator agreement""" score = 0 # EMA trend alignment with trade direction if (signal['direction'] == 'BUY' and signal['ema_trend']) or \ (signal['direction'] == 'SELL' and not signal['ema_trend']): score += 30 # RSI confirmation if signal['direction'] == 'BUY' and signal['rsi_value'] < 40: score += 25 elif signal['direction'] == 'SELL' and signal['rsi_value'] > 60: score += 25 # MACD confirmation if signal['macd_status'] == 'Bullish Crossover' and signal['direction'] == 'BUY': score += 25 elif signal['macd_status'] == 'Bearish Crossover' and signal['direction'] == 'SELL': score += 25 # Volume confirmation if signal.get('volume_confirmation', False): score += 20 return min(score, 100) # Cap at 100% def _handle_send_error(self, error, message): """Handle errors when sending messages""" now = time.time() self.error_count += 1 # Log the error logger.error(f"Failed to send alert: {error}") # Queue message for retry self.message_queue.append(message) # Alert admin if persistent errors if self.error_count > 3 and (now - self.last_error_time) > 300: # 5 minutes try: self.bot.send_message( ADMIN_CHAT_ID, f"⚠️ Alert System Error: {error}\nFailed to send {self.error_count} messages." ) self.last_error_time = now except: logger.critical("Failed to notify admin about errors") def send_system_alert(self, alert_type, message): """Send system-level alerts with appropriate formatting""" emoji_map = { 'error': '🚨', 'warning': '⚠️', 'info': 'ℹ️', 'success': '✅' } timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") full_message = f"{emoji_map.get(alert_type, 'ℹ️')} *{alert_type.upper()}*\n{timestamp}\n\n{message}" try: # Critical errors go to admin if alert_type == 'error': self.bot.send_message( ADMIN_CHAT_ID, full_message, parse_mode='Markdown' ) # All alerts go to main channel self.bot.send_message( TELEGRAM_CHAT_ID, full_message, parse_mode='Markdown' ) except Exception as e: logger.error(f"Failed to send system alert: {e}") def send_performance_report(self, report_data): """Send detailed performance report""" message = f""" 📈 *PERFORMANCE REPORT* 📈 📅 Period: {report_data['period']} 📊 *Summary* Total Trades: {report_data['total_trades']} Win Rate: {report_data['win_rate']}% Profit: ${report_data['profit']} Drawdown: {report_data['max_drawdown']}% 🏆 *Top Performing Assets* {self._format_top_assets(report_data['top_assets'])} ⚠️ *Underperforming Assets* {self._format_bottom_assets(report_data['bottom_assets'])} 📋 *Strategy Performance* {self._format_strategy_performance(report_data['strategy_performance'])} """ try: # Send performance chart if 'chart_path' in report_data and os.path.exists(report_data['chart_path']): with open(report_data['chart_path'], 'rb') as chart: self.bot.send_photo( TELEGRAM_CHAT_ID, chart, caption="Performance Chart" ) # Send detailed report self.bot.send_message( TELEGRAM_CHAT_ID, message, parse_mode='Markdown' ) except Exception as e: logger.error(f"Failed to send performance report: {e}") def _format_top_assets(self, assets): """Format top assets for report""" result = "" for i, asset in enumerate(assets[:3], 1): result += f"{i}. {asset['name']}: {asset['win_rate']}% win rate, ${asset['profit']}\n" return result def _format_bottom_assets(self, assets): """Format bottom assets for report""" result = "" for i, asset in enumerate(assets[:3], 1): result += f"{i}. {asset['name']}: {asset['win_rate']}% win rate, ${asset['profit']}\n" return result def _format_strategy_performance(self, strategies): """Format strategy performance for report""" result = "" for strategy in strategies: result += f"- {strategy['name']}: {strategy['win_rate']}% win rate\n" return result def process_message_queue(self): """Process queued messages that failed to send""" if not self.message_queue: return logger.info(f"Attempting to send {len(self.message_queue)} queued messages") # Try to send oldest message first message = self.message_queue[0] try: self.bot.send_message( TELEGRAM_CHAT_ID, message, parse_mode='Markdown' ) # Remove sent message self.message_queue.pop(0) logger.info("Successfully sent queued message") except Exception as e: logger.error(f"Failed to send queued message: {e}")Integration with Trading System
class WealthWarriorTrader: def __init__(self): self.telegram = TelegramAlertSystem() self.trade_history = [] self.active_trades = {} def execute_trade(self, signal): """Execute trade and send alert""" # Validate signal if not self._validate_signal(signal): self.telegram.send_system_alert( 'warning', f"Invalid signal detected for {signal.get('asset', 'unknown')}" ) return False # Generate chart for the signal chart_path = self._generate_chart(signal) signal['chart_path'] = chart_path # Calculate win probability signal['win_probability'] = self._calculate_win_probability(signal) # Calculate risk/reward signal['risk_reward'] = round( (signal['take_profit'] - signal['entry_price']) / (signal['entry_price'] - signal['stop_loss']), 2 ) if signal['direction'] == 'BUY' else round( (signal['entry_price'] - signal['take_profit']) / (signal['stop_loss'] - signal['entry_price']), 2 ) # Send alert self.telegram.send_trade_alert(signal) # Store trade trade_id = f"{signal['asset']}_{datetime.now().strftime('%Y%m%d%H%M%S')}" self.active_trades[trade_id] = { 'signal': signal, 'entry_time': datetime.now(), 'status': 'open' } return True def _validate_signal(self, signal): """Validate signal has all required fields""" required_fields = [ 'asset', 'direction', 'entry_price', 'timeframe', 'ema_trend', 'rsi_value', 'macd_status', 'position_size', 'stop_loss', 'take_profit' ] return all(field in signal for field in required_fields) def _generate_chart(self, signal): """Generate chart image for the signal""" # Implementation depends on your charting library # This is a placeholder return None def _calculate_win_probability(self, signal): """Calculate win probability based on historical performance""" # This would connect to your backtesting database # Placeholder implementation if signal['direction'] == 'BUY': if signal['rsi_value'] < 30 and signal['ema_trend']: return 92 return 85 else: if signal['rsi_value'] > 70 and not signal['ema_trend']: return 91 return 83 def update_trade_status(self, trade_id, new_status, exit_price=None): """Update trade status and send notification""" if trade_id not in self.active_trades: return False trade = self.active_trades[trade_id] trade['status'] = new_status if new_status == 'closed': trade['exit_time'] = datetime.now() trade['exit_price'] = exit_price # Calculate profit/loss entry_price = trade['signal']['entry_price'] direction = trade['signal']['direction'] if direction == 'BUY': profit_pct = (exit_price - entry_price) / entry_price * 100 else: profit_p
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.