fix new tickers filtering in ticker scanner, disable live trading, etc

.gitignore

@@ -29,6 +29,7 @@ src/core/linear_regression/
 src/core/markovs_chainss/
 # Ignore trading documentation (local reference only)
 src/core/trading/docs/
+CRITICAL_IMPROVEMENTS_SUMMARY.md
 # Ignore SQLite trading database
 trades.db
 *.db

src/core/ticker_scanner/core_enums.py

@@ -34,3 +34,49 @@ class GrowthCategory(Enum):
     STRONG = "strong"        # Top 25%
     MODERATE = "moderate"    # Top 50%
     SLOW = "slow"            # Bottom 50%
+
+
+class Timeframe(Enum):
+    """Historical data timeframe options"""
+    ONE_DAY = "1d"
+    FIVE_DAYS = "5d"
+    ONE_MONTH = "1mo"
+    THREE_MONTHS = "3mo"
+    SIX_MONTHS = "6mo"
+    ONE_YEAR = "1y"
+    TWO_YEARS = "2y"
+    FIVE_YEARS = "5y"
+    TEN_YEARS = "10y"
+    YTD = "ytd"
+    MAX = "max"
+
+
+# Minimum number of data points required for each timeframe
+# These values ensure sufficient historical data for reliable analysis
+# Note: 1d uses 30m intervals (~13 candles/day), 5d uses 1h intervals (~32 candles/5days)
+TIMEFRAME_MIN_DATA_POINTS = {
+    "1d": 10,       # 1 day with 30m intervals (~13 candles, conservative)
+    "5d": 25,       # 5 days with 1h intervals (~32 candles, conservative)
+    "1mo": 15,      # ~1 month
+    "3mo": 40,      # ~3 months
+    "6mo": 80,      # ~6 months
+    "1y": 150,      # ~1 year (250 trading days)
+    "2y": 300,      # ~2 years
+    "5y": 750,      # ~5 years
+    "10y": 1500,    # ~10 years
+    "ytd": 50,      # Year to date
+    "max": 100,     # Max available (conservative minimum)
+}
+
+
+def get_min_data_points_for_timeframe(timeframe: str) -> int:
+    """
+    Get the minimum number of data points required for a given timeframe.
+
+    Args:
+        timeframe: Timeframe string (e.g., "1y", "6mo")
+
+    Returns:
+        Minimum number of data points required
+    """
+    return TIMEFRAME_MIN_DATA_POINTS.get(timeframe, 100)

src/core/ticker_scanner/parallel_data_downloader.py

@@ -13,7 +13,7 @@ from concurrent.futures import ProcessPoolExecutor, as_completed
 
 import yfinance as yf
 
-from src.core.ticker_scanner.core_enums import StockExchange
+from src.core.ticker_scanner.core_enums import StockExchange, get_min_data_points_for_timeframe
 from src.core.ticker_scanner.tickers_provider import TickersProvider
 from src.telegram_bot.logger import main_logger as logger
 from src.core.ticker_scanner.ticker_cache import TickerCache
@@ -53,6 +53,9 @@ def fetch_prices(ticker: str, max_retries: int = MAX_RETRIES, use_cache: bool =
     Returns:
         dict {'ticker': ticker, 'prices': ndarray, 'dates': DatetimeIndex} or None if failed
     """
+    # Get minimum data points required for this timeframe
+    min_data_points = get_min_data_points_for_timeframe(period)
+
     # Set granular intervals for short periods to ensure enough data points
     interval = "1d"  # Default to daily
     if period == "1d":
@@ -75,8 +78,9 @@ def fetch_prices(ticker: str, max_retries: int = MAX_RETRIES, use_cache: bool =
 
             closes = df["Close"].dropna()
 
-            # Validate data
-            if len(closes) < MIN_DATA_POINTS:
+            # Validate minimum data points for the requested timeframe
+            if len(closes) < min_data_points:
+                logger.debug(f"{ticker}: Insufficient data for {period} timeframe. Got {len(closes)} points, need {min_data_points}")
                 return None
 
             # Ensure prices and dates have same length
@@ -155,27 +159,32 @@ def download_tickers_parallel(tickers: list[str], exchange: str,
     # Download remaining tickers
     all_results = cached_results.copy()
     all_failed = []
+    insufficient_data = []
 
     if tickers_to_download:
         logger.info(f"Downloading {len(tickers_to_download)} tickers...")
         for batch_num, ticker_batch in enumerate(batch(tickers_to_download, BATCH_SIZE), start=1):
             logger.info(f"Processing batch {batch_num}: {len(ticker_batch)} tickers")
-            results, failed = process_batch(ticker_batch, exchange, max_workers, period)
+            results, failed, filtered = process_batch(ticker_batch, exchange, max_workers, period)
             all_results.extend(results)
             all_failed.extend(failed)
+            insufficient_data.extend(filtered)
             # small sleep between batches to reduce rate-limit chance
             time.sleep(1 + random.random())
 
+    min_data_points = get_min_data_points_for_timeframe(period)
     logger.info(f"Total available: {len(all_results)} (cached: {len(cached_results)}, downloaded: {len(all_results) - len(cached_results)})")
     if all_failed:
-        logger.warning(f"Total failed: {len(all_failed)} - {all_failed[:10]}")  # Show first 10
+        logger.warning(f"Total failed to fetch: {len(all_failed)} - {all_failed[:10]}")  # Show first 10
+    if insufficient_data:
+        logger.info(f"Filtered out (insufficient data for {period}): {len(insufficient_data)} tickers - {insufficient_data[:10]}")  # Show first 10
 
     return all_results
 
-def process_batch(ticker_batch: list[str], exchange: str, max_workers: int, period: str = "max") -> tuple[list[dict[str, Any]], list[Any]]:
+def process_batch(ticker_batch: list[str], exchange: str, max_workers: int, period: str = "max") -> tuple[list[dict[str, Any]], list[Any], list[str]]:
     """
     Process a batch of tickers in parallel using multiprocessing.
-    Returns tuple (successful_results, failed_tickers)
+    Returns tuple (successful_results, failed_tickers, filtered_tickers)
 
     Args:
         ticker_batch: List of ticker symbols to process
@@ -187,6 +196,9 @@ def process_batch(ticker_batch: list[str], exchange: str, max_workers: int, peri
     """
     results = []
     failed = []
+    filtered = []
+    min_data_points = get_min_data_points_for_timeframe(period)
+
     with ProcessPoolExecutor(max_workers=max_workers) as executor:
         # Don't use cache in subprocess - already handled in main process
         futures = {executor.submit(fetch_prices, t, use_cache=False, period=period): t for t in ticker_batch}
@@ -195,14 +207,20 @@ def process_batch(ticker_batch: list[str], exchange: str, max_workers: int, peri
             try:
                 res = future.result()
                 if res:
-                    # Cache the result in the main process after download
-                    _cache.set(exchange, res['ticker'], res, period)
-                    results.append(res)
+                    # Check if we have sufficient data points for the timeframe
+                    data_points = len(res['prices'])
+                    if data_points >= min_data_points:
+                        # Cache the result in the main process after download
+                        _cache.set(exchange, res['ticker'], res, period)
+                        results.append(res)
+                    else:
+                        # Track tickers with insufficient data
+                        filtered.append(ticker)
                 else:
                     failed.append(ticker)
             except Exception:
                 failed.append(ticker)
-    return results, failed
+    return results, failed, filtered
 
 def run_parallel_data_downloader(exchange: StockExchange = StockExchange.NASDAQ,
                                  limit: int = 200,

src/telegram_bot/telegram_bot_service.py

@@ -234,13 +234,14 @@ class TelegramBotService:
                 "• /scan LSE max\n"
                 "• /scan ETF 3m 5\n"
             )
-            response += "\n🤖 <b>Trading Commands:</b>\n"
-            response += "/backtest TICKER - Backtest MACD strategy on stock (e.g., /backtest AAPL)\n"
-            response += "/live_status - Check live trading status and open positions\n"
-            response += "/portfolio - Get portfolio summary with P&L\n"
-            response += "/close_all - Emergency: Close all open positions\n\n"
-            response += "🤖 AI-powered trading insights\n"
-            response += "🔗 Powered by OpenRouter and Gemini API\n\n"
+            # Trading commands temporarily disabled
+            # response += "\n🤖 <b>Trading Commands:</b>\n"
+            # response += "/backtest TICKER - Backtest MACD strategy on stock (e.g., /backtest AAPL)\n"
+            # response += "/live_status - Check live trading status and open positions\n"
+            # response += "/portfolio - Get portfolio summary with P&L\n"
+            # response += "/close_all - Emergency: Close all open positions\n\n"
+            # response += "🤖 AI-powered trading insights\n"
+            # response += "🔗 Powered by OpenRouter and Gemini API\n\n"
 
         elif base_command == "/status":
             response = "✅ <b>Bot Status: Online</b>\n\n"
@@ -294,21 +295,21 @@ class TelegramBotService:
                                            text=None, user_name=user_name)
             return
 
-        elif base_command == "/backtest":
-            await self._handle_backtest_command(chat_id, command_parts, user_name)
-            return
+        # elif base_command == "/backtest":
+        #     await self._handle_backtest_command(chat_id, command_parts, user_name)
+        #     return
 
-        elif base_command == "/live_status":
-            await self._handle_live_status_command(chat_id, user_name)
-            return
+        # elif base_command == "/live_status":
+        #     await self._handle_live_status_command(chat_id, user_name)
+        #     return
 
-        elif base_command == "/portfolio":
-            await self._handle_portfolio_command(chat_id, user_name)
-            return
+        # elif base_command == "/portfolio":
+        #     await self._handle_portfolio_command(chat_id, user_name)
+        #     return
 
-        elif base_command == "/close_all":
-            await self._handle_close_all_command(chat_id, user_name)
-            return
+        # elif base_command == "/close_all":
+        #     await self._handle_close_all_command(chat_id, user_name)
+        #     return
 
         else:
             response = f"❓ Unknown command: {command}\n\n"
@@ -849,370 +850,372 @@ class TelegramBotService:
             error_msg += "Please try again later."
             await self.send_message_via_proxy(chat_id, error_msg)
 
-    async def _handle_backtest_command(
-            self, chat_id: int, command_parts: list[str], user_name: str
-    ) -> None:
-        """
-        Handle backtest command
-        Usage: /backtest TICKER [PERIOD]
-        Example: /backtest AAPL 6mo
-        """
-        if len(command_parts) < 2:
-            await self.send_message_via_proxy(
-                chat_id,
-                "❌ Please specify a ticker: /backtest AAPL [period]\n\n"
-                "Supported periods: 1mo, 3mo, 6mo, 1y, 2y, 5y, max (default: 1y)\n\n"
-                "Examples:\n• /backtest AAPL\n• /backtest TSLA 6mo"
-            )
-            return
-
-        ticker = command_parts[1].upper()
-        period = command_parts[2].lower() if len(command_parts) > 2 else "1y"
-
-        # Validate period
-        valid_periods = ["1mo", "3mo", "6mo", "1y", "2y", "5y", "max"]
-        if period not in valid_periods:
-            await self.send_message_via_proxy(
-                chat_id,
-                f"❌ Invalid period: {period}\n\n"
-                f"Supported: {', '.join(valid_periods)}"
-            )
-            return
-
-        await self.send_message_via_proxy(
-            chat_id,
-            f"⏳ <b>Backtesting MACD strategy on {ticker} ({period})...</b>\n\n"
-            f"📥 Downloading historical data...\n"
-            f"📊 Generating trading signals...\n"
-            f"🧮 Simulating trades...\n"
-            f"📈 Calculating metrics..."
-        )
-
-        try:
-            import yfinance as yf
-            import numpy as np
-
-            # Download data
-            data = yf.download(ticker, period=period, progress=False)
-
-            if data.empty or len(data) < 50:
-                await self.send_message_via_proxy(
-                    chat_id,
-                    f"❌ Not enough historical data for {ticker}\n\n"
-                    f"Need at least 50 candles, got {len(data)}"
-                )
-                return
-
-            # Initialize strategy and backtest
-            strategy = AdvancedMACDStrategy()
-            risk_engine = RiskEngine(initial_capital=10000, max_risk_per_trade=0.02)
-            backtest = VectorizedBacktest(
-                strategy=strategy,
-                risk_engine=risk_engine,
-                initial_capital=10000,
-                commission=0.001
-            )
-
-            # Run backtest
-            trades, equity_curve, metrics = backtest.run(data, ticker)
-
-            # Format results
-            result_text = self._format_backtest_results(ticker, trades, equity_curve, metrics, period)
-            await self.send_long_message(chat_id, result_text)
-
-        except ImportError:
-            await self.send_message_via_proxy(
-                chat_id,
-                "❌ Required library not installed: yfinance\n\n"
-                "Please install: pip install yfinance"
-            )
-        except Exception as e:
-            logger.error(f"Error in backtest command: {e}", exc_info=True)
-            await self.send_message_via_proxy(
-                chat_id,
-                f"❌ Backtest failed for {ticker}: {str(e)}"
-            )
-
-    async def _handle_live_status_command(
-            self, chat_id: int, user_name: str
-    ) -> None:
-        """
-        Handle live_status command
-        Shows current trading status and open positions
-        """
-        if not self.live_trader or not self.live_trader.is_running:
-            await self.send_message_via_proxy(
-                chat_id,
-                "⛔ <b>Live trading is not active</b>\n\n"
-                "Status: Offline\n\n"
-                "To start live trading:\n"
-                "1. Ensure Alpaca API keys are configured\n"
-                "2. Use `/live_start AAPL NVDA TSLA` to start trading symbols\n"
-                "3. Monitor trades with `/live_status` and `/portfolio`"
-            )
-            return
-
-        try:
-            status = self.live_trader.get_status()
-            account = self.live_trader.broker.get_account()
-            positions = self.live_trader.broker.get_positions()
-
-            response = "🟢 <b>Live Trading Status: ACTIVE</b>\n\n"
-            response += f"💰 <b>Account:</b>\n"
-            response += f"  Equity: ${account.equity:,.2f}\n"
-            response += f"  Cash: ${account.cash:,.2f}\n"
-            response += f"  Buying Power: ${account.buying_power:,.2f}\n\n"
-
-            response += f"📊 <b>Trading:</b>\n"
-            response += f"  Symbols: {', '.join(status['symbols'])}\n"
-            response += f"  Approval Mode: {'ON' if status['approval_mode'] else 'OFF'}\n"
-            response += f"  Pending Approvals: {status['pending_approvals']}\n"
-            response += f"  Open Positions: {status['open_positions']}\n\n"
-
-            response += f"📈 <b>Performance:</b>\n"
-            response += f"  Executed Signals: {status['executed_signals']}\n"
-            response += f"  Skipped Signals: {status['skipped_signals']}\n\n"
-
-            if positions:
-                response += "📍 <b>Open Positions:</b>\n"
-                for pos in positions:
-                    response += f"  {pos.symbol}: {pos.quantity} @ ${pos.entry_price:.2f}\n"
-                    response += f"    Current: ${pos.current_price:.2f} | "
-                    response += f"P&L: ${pos.unrealized_pnl:.2f} ({pos.unrealized_pnl_pct:.1f}%)\n"
-
-            await self.send_message_via_proxy(chat_id, response)
-
-        except Exception as e:
-            logger.error(f"Error getting live status: {e}", exc_info=True)
-            await self.send_message_via_proxy(
-                chat_id,
-                f"❌ Error retrieving live status: {str(e)}"
-            )
-
-    async def _handle_portfolio_command(
-            self, chat_id: int, user_name: str
-    ) -> None:
-        """
-        Handle portfolio command
-        Shows detailed portfolio summary with P&L
-        """
-        if not self.live_trader or not self.live_trader.is_running:
-            await self.send_message_via_proxy(
-                chat_id,
-                "⛔ <b>Live trading is not active</b>\n\n"
-                "Cannot retrieve portfolio. Start live trading first."
-            )
-            return
-
-        try:
-            summary = self.live_trader.order_manager.get_open_trades_summary()
-            execution_history = self.live_trader.order_manager.get_execution_history(limit=10)
-
-            response = "💼 <b>PORTFOLIO SUMMARY</b>\n"
-            response += "━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
-
-            response += f"💰 <b>Account Overview:</b>\n"
-            response += f"  Total Equity: ${summary['total_equity']:,.2f}\n"
-            response += f"  Cash Available: ${summary['total_cash']:,.2f}\n"
-            response += f"  Unrealized P&L: ${summary['total_unrealized_pnl']:,.2f}\n"
-            response += f"  Portfolio Heat: {summary['portfolio_heat']*100:.2f}%\n"
-            response += f"  Open Positions: {summary['total_positions']}\n\n"
-
-            if summary['positions']:
-                response += "📍 <b>Open Positions:</b>\n"
-                for pos in summary['positions']:
-                    emoji = "📈" if pos['unrealized_pnl'] > 0 else "📉"
-                    response += f"  {emoji} {pos['symbol']}\n"
-                    response += f"     Qty: {pos['quantity']} @ ${pos['entry_price']:.2f}\n"
-                    response += f"     P&L: ${pos['unrealized_pnl']:.2f} ({pos['unrealized_pnl_pct']:+.1f}%)\n"
-            else:
-                response += "No open positions\n\n"
-
-            if execution_history:
-                response += "\n📊 <b>Recent Executions (last 10):</b>\n"
-                for report in execution_history[:5]:  # Show last 5 to fit in message
-                    status_emoji = "✅" if report.status == "filled" else "❌"
-                    response += f"  {status_emoji} {report.symbol} {report.side.upper()}\n"
-                    response += f"     {report.status.upper()} @ ${report.entry_price:.2f}\n"
-
-            await self.send_message_via_proxy(chat_id, response)
-
-        except Exception as e:
-            logger.error(f"Error getting portfolio: {e}", exc_info=True)
-            await self.send_message_via_proxy(
-                chat_id,
-                f"❌ Error retrieving portfolio: {str(e)}"
-            )
-
-    async def _handle_close_all_command(
-            self, chat_id: int, user_name: str
-    ) -> None:
-        """
-        Handle close_all command
-        Emergency: Close all open positions
-        """
-        if not self.live_trader or not self.live_trader.is_running:
-            await self.send_message_via_proxy(
-                chat_id,
-                "⛔ <b>Live trading is not active</b>\n\n"
-                "No positions to close."
-            )
-            return
-
-        try:
-            positions = self.live_trader.broker.get_positions()
-
-            if not positions:
-                await self.send_message_via_proxy(
-                    chat_id,
-                    "✅ <b>No open positions to close</b>\n\n"
-                    "Portfolio is flat."
-                )
-                return
-
-            await self.send_message_via_proxy(
-                chat_id,
-                "⚠️ <b>CLOSING ALL POSITIONS...</b>\n\n"
-                f"Closing {len(positions)} position(s):\n" +
-                "\n".join([f"  • {p.symbol}: {p.quantity} shares" for p in positions])
-            )
-
-            # Close all positions
-            closed_orders = self.live_trader.order_manager.close_all()
-
-            response = "✅ <b>ALL POSITIONS CLOSED</b>\n\n"
-            response += f"Closed {len(closed_orders)} position(s):\n"
-            for order in closed_orders:
-                response += f"  ✓ {order.symbol}: {order.quantity} shares\n"
-            response += f"\n⏰ Time: {datetime.now().strftime('%H:%M:%S')}"
-
-            await self.send_message_via_proxy(chat_id, response)
-            logger.info(f"All positions closed via Telegram command by {user_name}")
-
-        except Exception as e:
-            logger.error(f"Error closing all positions: {e}", exc_info=True)
-            await self.send_message_via_proxy(
-                chat_id,
-                f"❌ Error closing positions: {str(e)}"
-            )
-
-    def _format_backtest_results(
-            self, ticker: str, trades: list, equity_curve: list, metrics: dict, period: str
-    ) -> str:
-        """Format backtest results for Telegram"""
-        try:
-            if not trades or len(trades) == 0:
-                return (
-                    f"📊 <b>Backtest Results: {ticker} ({period})</b>\n\n"
-                    f"⚠️ No trades generated\n"
-                    f"The MACD strategy did not generate any signals on this timeframe."
-                )
-
-            # Extract metrics
-            win_rate = metrics.get('win_rate', 0)
-            total_return = metrics.get('total_return', 0)
-            sharpe = metrics.get('sharpe_ratio', 0)
-            max_dd = metrics.get('max_drawdown', 0)
-            profit_factor = metrics.get('profit_factor', 0)
-            trades_count = metrics.get('total_trades', 0)
-
-            # Emojis based on metrics
-            return_emoji = "📈" if total_return > 0 else "📉"
-            wr_emoji = "🟢" if win_rate > 0.5 else "🔴" if win_rate < 0.3 else "🟡"
-            sharpe_emoji = "🟢" if sharpe > 1.0 else "🟡" if sharpe > 0 else "🔴"
-
-            result = f"""
-📊 <b>Backtest Results: {ticker}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-⏰ Period: {period}
-📉 Data Points: {len(equity_curve)} candles
-
-📈 <b>Performance Metrics:</b>
-{return_emoji} Total Return: {total_return:+.2f}%
-🎯 Win Rate: {win_rate*100:.1f}% {wr_emoji}
-📊 Profit Factor: {profit_factor:.2f}
-💹 Sharpe Ratio: {sharpe:.2f} {sharpe_emoji}
-📉 Max Drawdown: {max_dd*100:.1f}%
-
-📋 <b>Trade Statistics:</b>
-🔔 Total Trades: {trades_count}
-✅ Winning Trades: {sum(1 for t in trades if t.get('pnl', 0) > 0)}
-❌ Losing Trades: {sum(1 for t in trades if t.get('pnl', 0) < 0)}
-
-💰 <b>Trade Summary (first 5):</b>
-"""
-            for i, trade in enumerate(trades[:5]):
-                side = "BUY" if trade.get('side') == 'buy' else "SELL"
-                entry = trade.get('entry_price', 0)
-                exit_p = trade.get('exit_price', 0)
-                pnl = trade.get('pnl', 0)
-                emoji = "✅" if pnl > 0 else "❌"
-                result += f"{emoji} {i+1}. {side} @ ${entry:.2f} → ${exit_p:.2f} | P&L: ${pnl:+.2f}\n"
-
-            result += f"\n⚠️ <b>Disclaimer:</b>\n"
-            result += f"Backtesting results are based on historical data.\n"
-            result += f"Past performance does not guarantee future results.\n"
-            result += f"Use as analysis tool only, not trading advice."
-
-            return result
-
-        except Exception as e:
-            logger.error(f"Error formatting backtest results: {e}")
-            return f"❌ Error formatting backtest results: {str(e)}"
-
-    async def process_approval_callback(self, approval_id: str, action: str, chat_id: int) -> None:
-        """
-        Process approval callback from Telegram buttons
-        Called when user clicks approve/reject button
-
-        Args:
-            approval_id: ID of the approval to process
-            action: 'approve' or 'reject'
-            chat_id: Chat ID for sending confirmation
-        """
-        try:
-            if not self.live_trader:
-                await self.send_message_via_proxy(
-                    chat_id,
-                    "❌ Live trader not initialized"
-                )
-                return
-
-            if action.lower() == "approve":
-                result = await self.live_trader.approve_signal(approval_id)
-                if result:
-                    await self.send_message_via_proxy(
-                        chat_id,
-                        f"✅ <b>Signal Approved</b>\n\n"
-                        f"Approval ID: {approval_id}\n"
-                        f"Status: Executing order..."
-                    )
-                    logger.info(f"Signal {approval_id} approved by user")
-                else:
-                    await self.send_message_via_proxy(
-                        chat_id,
-                        f"❌ Approval {approval_id} not found or already processed"
-                    )
-
-            elif action.lower() == "reject":
-                result = await self.live_trader.reject_signal(approval_id)
-                if result:
-                    await self.send_message_via_proxy(
-                        chat_id,
-                        f"❌ <b>Signal Rejected</b>\n\n"
-                        f"Approval ID: {approval_id}\n"
-                        f"Status: Signal skipped"
-                    )
-                    logger.info(f"Signal {approval_id} rejected by user")
-                else:
-                    await self.send_message_via_proxy(
-                        chat_id,
-                        f"❌ Approval {approval_id} not found or already processed"
-                    )
-
-        except Exception as e:
-            logger.error(f"Error processing approval callback: {e}", exc_info=True)
-            await self.send_message_via_proxy(
-                chat_id,
-                f"❌ Error processing approval: {str(e)}"
-            )
+    # # Trading commands temporarily disabled for live trading maintenance
+    # async def _handle_backtest_command(
+    #         self, chat_id: int, command_parts: list[str], user_name: str
+    # ) -> None:
+    #     """
+    #     Handle backtest command
+    #     Usage: /backtest TICKER [PERIOD]
+    #     Example: /backtest AAPL 6mo
+    #     """
+    #     if len(command_parts) < 2:
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             "❌ Please specify a ticker: /backtest AAPL [period]\n\n"
+    #             "Supported periods: 1mo, 3mo, 6mo, 1y, 2y, 5y, max (default: 1y)\n\n"
+    #             "Examples:\n• /backtest AAPL\n• /backtest TSLA 6mo"
+    #         )
+    #         return
+    #
+    #     ticker = command_parts[1].upper()
+    #     period = command_parts[2].lower() if len(command_parts) > 2 else "1y"
+    #
+    #     # Validate period
+    #     valid_periods = ["1mo", "3mo", "6mo", "1y", "2y", "5y", "max"]
+    #     if period not in valid_periods:
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             f"❌ Invalid period: {period}\n\n"
+    #             f"Supported: {', '.join(valid_periods)}"
+    #         )
+    #         return
+    #
+    #     await self.send_message_via_proxy(
+    #         chat_id,
+    #         f"⏳ <b>Backtesting MACD strategy on {ticker} ({period})...</b>\n\n"
+    #         f"📥 Downloading historical data...\n"
+    #         f"📊 Generating trading signals...\n"
+    #         f"🧮 Simulating trades...\n"
+    #         f"📈 Calculating metrics..."
+    #     )
+    #
+    #     try:
+    #         import yfinance as yf
+    #         import numpy as np
+    #
+    #         # Download data
+    #         data = yf.download(ticker, period=period, progress=False)
+    #
+    #         if data.empty or len(data) < 50:
+    #             await self.send_message_via_proxy(
+    #                 chat_id,
+    #                 f"❌ Not enough historical data for {ticker}\n\n"
+    #                 f"Need at least 50 candles, got {len(data)}"
+    #             )
+    #             return
+    #
+    #         # Initialize strategy and backtest
+    #         strategy = AdvancedMACDStrategy()
+    #         risk_engine = RiskEngine(initial_capital=10000, max_risk_per_trade=0.02)
+    #         backtest = VectorizedBacktest(
+    #             strategy=strategy,
+    #             risk_engine=risk_engine,
+    #             initial_capital=10000,
+    #             commission=0.001
+    #         )
+    #
+    #         # Run backtest
+    #         trades, equity_curve, metrics = backtest.run(data, ticker)
+    #
+    #         # Format results
+    #         result_text = self._format_backtest_results(ticker, trades, equity_curve, metrics, period)
+    #         await self.send_long_message(chat_id, result_text)
+    #
+    #     except ImportError:
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             "❌ Required library not installed: yfinance\n\n"
+    #             "Please install: pip install yfinance"
+    #         )
+    #     except Exception as e:
+    #         logger.error(f"Error in backtest command: {e}", exc_info=True)
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             f"❌ Backtest failed for {ticker}: {str(e)}"
+    #         )
+
+    # async def _handle_live_status_command(
+    #         self, chat_id: int, user_name: str
+    # ) -> None:
+    #     """
+    #     Handle live_status command
+    #     Shows current trading status and open positions
+    #     """
+    #     if not self.live_trader or not self.live_trader.is_running:
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             "⛔ <b>Live trading is not active</b>\n\n"
+    #             "Status: Offline\n\n"
+    #             "To start live trading:\n"
+    #             "1. Ensure Alpaca API keys are configured\n"
+    #             "2. Use `/live_start AAPL NVDA TSLA` to start trading symbols\n"
+    #             "3. Monitor trades with `/live_status` and `/portfolio`"
+    #         )
+    #         return
+    #
+    #     try:
+    #         status = self.live_trader.get_status()
+    #         account = self.live_trader.broker.get_account()
+    #         positions = self.live_trader.broker.get_positions()
+    #
+    #         response = "🟢 <b>Live Trading Status: ACTIVE</b>\n\n"
+    #         response += f"💰 <b>Account:</b>\n"
+    #         response += f"  Equity: ${account.equity:,.2f}\n"
+    #         response += f"  Cash: ${account.cash:,.2f}\n"
+    #         response += f"  Buying Power: ${account.buying_power:,.2f}\n\n"
+    #
+    #         response += f"📊 <b>Trading:</b>\n"
+    #         response += f"  Symbols: {', '.join(status['symbols'])}\n"
+    #         response += f"  Approval Mode: {'ON' if status['approval_mode'] else 'OFF'}\n"
+    #         response += f"  Pending Approvals: {status['pending_approvals']}\n"
+    #         response += f"  Open Positions: {status['open_positions']}\n\n"
+    #
+    #         response += f"📈 <b>Performance:</b>\n"
+    #         response += f"  Executed Signals: {status['executed_signals']}\n"
+    #         response += f"  Skipped Signals: {status['skipped_signals']}\n\n"
+    #
+    #         if positions:
+    #             response += "📍 <b>Open Positions:</b>\n"
+    #             for pos in positions:
+    #                 response += f"  {pos.symbol}: {pos.quantity} @ ${pos.entry_price:.2f}\n"
+    #                 response += f"    Current: ${pos.current_price:.2f} | "
+    #                 response += f"P&L: ${pos.unrealized_pnl:.2f} ({pos.unrealized_pnl_pct:.1f}%)\n"
+    #
+    #         await self.send_message_via_proxy(chat_id, response)
+    #
+    #     except Exception as e:
+    #         logger.error(f"Error getting live status: {e}", exc_info=True)
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             f"❌ Error retrieving live status: {str(e)}"
+    #         )
+
+    # async def _handle_portfolio_command(
+    #         self, chat_id: int, user_name: str
+    # ) -> None:
+    #     """
+    #     Handle portfolio command
+    #     Shows detailed portfolio summary with P&L
+    #     """
+    #     if not self.live_trader or not self.live_trader.is_running:
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             "⛔ <b>Live trading is not active</b>\n\n"
+    #             "Cannot retrieve portfolio. Start live trading first."
+    #         )
+    #         return
+    #
+    #     try:
+    #         summary = self.live_trader.order_manager.get_open_trades_summary()
+    #         execution_history = self.live_trader.order_manager.get_execution_history(limit=10)
+    #
+    #         response = "💼 <b>PORTFOLIO SUMMARY</b>\n"
+    #         response += "━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
+    #
+    #         response += f"💰 <b>Account Overview:</b>\n"
+    #         response += f"  Total Equity: ${summary['total_equity']:,.2f}\n"
+    #         response += f"  Cash Available: ${summary['total_cash']:,.2f}\n"
+    #         response += f"  Unrealized P&L: ${summary['total_unrealized_pnl']:,.2f}\n"
+    #         response += f"  Portfolio Heat: {summary['portfolio_heat']*100:.2f}%\n"
+    #         response += f"  Open Positions: {summary['total_positions']}\n\n"
+    #
+    #         if summary['positions']:
+    #             response += "📍 <b>Open Positions:</b>\n"
+    #             for pos in summary['positions']:
+    #                 emoji = "📈" if pos['unrealized_pnl'] > 0 else "📉"
+    #                 response += f"  {emoji} {pos['symbol']}\n"
+    #                 response += f"     Qty: {pos['quantity']} @ ${pos['entry_price']:.2f}\n"
+    #                 response += f"     P&L: ${pos['unrealized_pnl']:.2f} ({pos['unrealized_pnl_pct']:+.1f}%)\n"
+    #         else:
+    #             response += "No open positions\n\n"
+    #
+    #         if execution_history:
+    #             response += "\n📊 <b>Recent Executions (last 10):</b>\n"
+    #             for report in execution_history[:5]:  # Show last 5 to fit in message
+    #                 status_emoji = "✅" if report.status == "filled" else "❌"
+    #                 response += f"  {status_emoji} {report.symbol} {report.side.upper()}\n"
+    #                 response += f"     {report.status.upper()} @ ${report.entry_price:.2f}\n"
+    #
+    #         await self.send_message_via_proxy(chat_id, response)
+    #
+    #     except Exception as e:
+    #         logger.error(f"Error getting portfolio: {e}", exc_info=True)
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             f"❌ Error retrieving portfolio: {str(e)}"
+    #         )
+
+    # async def _handle_close_all_command(
+    #         self, chat_id: int, user_name: str
+    # ) -> None:
+    #     """
+    #     Handle close_all command
+    #     Emergency: Close all open positions
+    #     """
+    #     if not self.live_trader or not self.live_trader.is_running:
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             "⛔ <b>Live trading is not active</b>\n\n"
+    #             "No positions to close."
+    #         )
+    #         return
+    #
+    #     try:
+    #         positions = self.live_trader.broker.get_positions()
+    #
+    #         if not positions:
+    #             await self.send_message_via_proxy(
+    #                 chat_id,
+    #                 "✅ <b>No open positions to close</b>\n\n"
+    #                 "Portfolio is flat."
+    #             )
+    #             return
+    #
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             "⚠️ <b>CLOSING ALL POSITIONS...</b>\n\n"
+    #             f"Closing {len(positions)} position(s):\n" +
+    #             "\n".join([f"  • {p.symbol}: {p.quantity} shares" for p in positions])
+    #         )
+    #
+    #         # Close all positions
+    #         closed_orders = self.live_trader.order_manager.close_all()
+    #
+    #         response = "✅ <b>ALL POSITIONS CLOSED</b>\n\n"
+    #         response += f"Closed {len(closed_orders)} position(s):\n"
+    #         for order in closed_orders:
+    #             response += f"  ✓ {order.symbol}: {order.quantity} shares\n"
+    #         response += f"\n⏰ Time: {datetime.now().strftime('%H:%M:%S')}"
+    #
+    #         await self.send_message_via_proxy(chat_id, response)
+    #         logger.info(f"All positions closed via Telegram command by {user_name}")
+    #
+    #     except Exception as e:
+    #         logger.error(f"Error closing all positions: {e}", exc_info=True)
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             f"❌ Error closing positions: {str(e)}"
+    #         )
+
+    # # Trading feature disabled - commented out for maintenance
+    # def _format_backtest_results(
+    #         self, ticker: str, trades: list, equity_curve: list, metrics: dict, period: str
+    # ) -> str:
+    #     """Format backtest results for Telegram"""
+    #     try:
+    #         if not trades or len(trades) == 0:
+    #             return (
+    #                 f"📊 <b>Backtest Results: {ticker} ({period})</b>\n\n"
+    #                 f"⚠️ No trades generated\n"
+    #                 f"The MACD strategy did not generate any signals on this timeframe."
+    #             )
+    #
+    #         # Extract metrics
+    #         win_rate = metrics.get('win_rate', 0)
+    #         total_return = metrics.get('total_return', 0)
+    #         sharpe = metrics.get('sharpe_ratio', 0)
+    #         max_dd = metrics.get('max_drawdown', 0)
+    #         profit_factor = metrics.get('profit_factor', 0)
+    #         trades_count = metrics.get('total_trades', 0)
+    #
+    #         # Emojis based on metrics
+    #         return_emoji = "📈" if total_return > 0 else "📉"
+    #         wr_emoji = "🟢" if win_rate > 0.5 else "🔴" if win_rate < 0.3 else "🟡"
+    #         sharpe_emoji = "🟢" if sharpe > 1.0 else "🟡" if sharpe > 0 else "🔴"
+    #
+    #         result = f"""
+    # 📊 <b>Backtest Results: {ticker}</b>
+    # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    # ⏰ Period: {period}
+    # 📉 Data Points: {len(equity_curve)} candles
+    #
+    # 📈 <b>Performance Metrics:</b>
+    # {return_emoji} Total Return: {total_return:+.2f}%
+    # 🎯 Win Rate: {win_rate*100:.1f}% {wr_emoji}
+    # 📊 Profit Factor: {profit_factor:.2f}
+    # 💹 Sharpe Ratio: {sharpe:.2f} {sharpe_emoji}
+    # 📉 Max Drawdown: {max_dd*100:.1f}%
+    #
+    # 📋 <b>Trade Statistics:</b>
+    # 🔔 Total Trades: {trades_count}
+    # ✅ Winning Trades: {sum(1 for t in trades if t.get('pnl', 0) > 0)}
+    # ❌ Losing Trades: {sum(1 for t in trades if t.get('pnl', 0) < 0)}
+    #
+    # 💰 <b>Trade Summary (first 5):</b>
+    # """
+    #         for i, trade in enumerate(trades[:5]):
+    #             side = "BUY" if trade.get('side') == 'buy' else "SELL"
+    #             entry = trade.get('entry_price', 0)
+    #             exit_p = trade.get('exit_price', 0)
+    #             pnl = trade.get('pnl', 0)
+    #             emoji = "✅" if pnl > 0 else "❌"
+    #             result += f"{emoji} {i+1}. {side} @ ${entry:.2f} → ${exit_p:.2f} | P&L: ${pnl:+.2f}\n"
+    #
+    #         result += f"\n⚠️ <b>Disclaimer:</b>\n"
+    #         result += f"Backtesting results are based on historical data.\n"
+    #         result += f"Past performance does not guarantee future results.\n"
+    #         result += f"Use as analysis tool only, not trading advice."
+    #
+    #         return result
+    #
+    #     except Exception as e:
+    #         logger.error(f"Error formatting backtest results: {e}")
+    #         return f"❌ Error formatting backtest results: {str(e)}"
+
+    # async def process_approval_callback(self, approval_id: str, action: str, chat_id: int) -> None:
+    #     """
+    #     Process approval callback from Telegram buttons
+    #     Called when user clicks approve/reject button
+    #
+    #     Args:
+    #         approval_id: ID of the approval to process
+    #         action: 'approve' or 'reject'
+    #         chat_id: Chat ID for sending confirmation
+    #     """
+    #     try:
+    #         if not self.live_trader:
+    #             await self.send_message_via_proxy(
+    #                 chat_id,
+    #                 "❌ Live trader not initialized"
+    #             )
+    #             return
+    #
+    #         if action.lower() == "approve":
+    #             result = await self.live_trader.approve_signal(approval_id)
+    #             if result:
+    #                 await self.send_message_via_proxy(
+    #                     chat_id,
+    #                     f"✅ <b>Signal Approved</b>\n\n"
+    #                     f"Approval ID: {approval_id}\n"
+    #                     f"Status: Executing order..."
+    #                 )
+    #                 logger.info(f"Signal {approval_id} approved by user")
+    #             else:
+    #                 await self.send_message_via_proxy(
+    #                     chat_id,
+    #                     f"❌ Approval {approval_id} not found or already processed"
+    #                 )
+    #
+    #         elif action.lower() == "reject":
+    #             result = await self.live_trader.reject_signal(approval_id)
+    #             if result:
+    #                 await self.send_message_via_proxy(
+    #                     chat_id,
+    #                     f"❌ <b>Signal Rejected</b>\n\n"
+    #                     f"Approval ID: {approval_id}\n"
+    #                     f"Status: Signal skipped"
+    #                 )
+    #                 logger.info(f"Signal {approval_id} rejected by user")
+    #             else:
+    #                 await self.send_message_via_proxy(
+    #                     chat_id,
+    #                     f"❌ Approval {approval_id} not found or already processed"
+    #                 )
+    #
+    #     except Exception as e:
+    #         logger.error(f"Error processing approval callback: {e}", exc_info=True)
+    #         await self.send_message_via_proxy(
+    #             chat_id,
+    #             f"❌ Error processing approval: {str(e)}"
+    #         )