add a draft for monitoring, ema crossover strategy, etc

examples/ema_strategy_example.py

@@ -0,0 +1,231 @@
+"""
+EMA 50/200 Crossover Strategy - Usage Examples
+
+Demonstrates the Golden Cross / Death Cross trading strategy.
+"""
+
+import pandas as pd
+import yfinance as yf
+from src.core.trading.ema_crossover_strategy import EMACrossoverStrategy
+
+
+def example_1_basic_usage():
+    """Example 1: Basic EMA crossover analysis."""
+    print("\n=== Example 1: Basic EMA Crossover ===\n")
+
+    # Initialize strategy
+    strategy = EMACrossoverStrategy(
+        fast_ema=50,
+        slow_ema=200,
+        use_volume_filter=True,
+        use_adx_filter=True
+    )
+
+    # Download data
+    ticker = "AAPL"
+    data = yf.download(ticker, period="2y", progress=False)
+
+    # Generate signals
+    signals = strategy.generate_signals(data, ticker=ticker)
+
+    # Display recent signals
+    print(f"Analysis for {ticker}:")
+    print(f"  Current Price: ${signals['Close'].iloc[-1]:.2f}")
+    print(f"  EMA 50: ${signals['EMA_Fast'].iloc[-1]:.2f}")
+    print(f"  EMA 200: ${signals['EMA_Slow'].iloc[-1]:.2f}")
+    print(f"  Position: {strategy.get_current_position(signals)}")
+
+    # Find recent crossovers
+    golden_crosses = signals[signals['Golden_Cross']].tail(3)
+    death_crosses = signals[signals['Death_Cross']].tail(3)
+
+    if not golden_crosses.empty:
+        print(f"\nRecent Golden Crosses:")
+        for date, row in golden_crosses.iterrows():
+            print(f"  {date.date()}: ${row['Close']:.2f}")
+
+    if not death_crosses.empty:
+        print(f"\nRecent Death Crosses:")
+        for date, row in death_crosses.iterrows():
+            print(f"  {date.date()}: ${row['Close']:.2f}")
+
+
+def example_2_market_scan():
+    """Example 2: Scan market for signals."""
+    print("\n=== Example 2: Market Scan ===\n")
+
+    # Initialize strategy
+    strategy = EMACrossoverStrategy()
+
+    # Define tickers to scan
+    tickers = [
+        "AAPL", "MSFT", "GOOGL", "AMZN", "NVDA",
+        "TSLA", "META", "AMD", "NFLX", "DIS"
+    ]
+
+    # Data loader function
+    def load_data(ticker, period):
+        return yf.download(ticker, period=period, progress=False)
+
+    # Scan market
+    print("Scanning market for EMA crossover signals...\n")
+    results = strategy.scan_market(tickers, load_data, period="1y")
+
+    if not results.empty:
+        print(f"\nFound {len(results)} signals:\n")
+        print(results.to_string(index=False))
+    else:
+        print("\nNo signals found.")
+
+
+def example_3_custom_parameters():
+    """Example 3: Custom EMA parameters."""
+    print("\n=== Example 3: Custom EMA 20/50 ===\n")
+
+    # Faster crossover (20/50 instead of 50/200)
+    strategy = EMACrossoverStrategy(
+        fast_ema=20,
+        slow_ema=50,
+        atr_multiplier_sl=1.5,  # Tighter stop
+        atr_multiplier_tp=3.0,   # Closer target
+        adx_threshold=25,        # Stronger trend required
+        use_volume_filter=True,
+        use_adx_filter=True
+    )
+
+    print(strategy.get_strategy_description())
+
+    # Test on volatile stock
+    ticker = "NVDA"
+    data = yf.download(ticker, period="6mo", progress=False)
+    signals = strategy.generate_signals(data, ticker=ticker)
+
+    print(f"\nAnalysis for {ticker}:")
+    print(f"  Current Position: {strategy.get_current_position(signals)}")
+    print(f"  ADX: {signals['ADX'].iloc[-1]:.1f}")
+    print(f"  Volume Ratio: {signals['Volume_Ratio'].iloc[-1]:.2f}x")
+
+
+def example_4_signal_details():
+    """Example 4: Detailed signal analysis."""
+    print("\n=== Example 4: Signal Details ===\n")
+
+    strategy = EMACrossoverStrategy()
+
+    ticker = "TSLA"
+    data = yf.download(ticker, period="1y", progress=False)
+    signals = strategy.generate_signals(data, ticker=ticker)
+
+    # Find most recent signal
+    recent_long = signals[signals['Signal_Long']].tail(1)
+    recent_short = signals[signals['Signal_Short']].tail(1)
+
+    if not recent_long.empty:
+        row = recent_long.iloc[0]
+        print(f"Most Recent LONG Signal for {ticker}:")
+        print(f"  Date: {recent_long.index[0].date()}")
+        print(f"  Price: ${row['Close']:.2f}")
+        print(f"  Stop Loss: ${row['Stop_Loss_Long']:.2f} ({((row['Stop_Loss_Long']/row['Close']-1)*100):.1f}%)")
+        print(f"  Take Profit: ${row['Take_Profit_Long']:.2f} ({((row['Take_Profit_Long']/row['Close']-1)*100):.1f}%)")
+        print(f"  R:R Ratio: {row['RR_Ratio']:.1f}:1")
+        print(f"  ADX: {row['ADX']:.1f}")
+        print(f"  Volume: {row['Volume_Ratio']:.2f}x average")
+
+    if not recent_short.empty:
+        row = recent_short.iloc[0]
+        print(f"\nMost Recent SHORT Signal for {ticker}:")
+        print(f"  Date: {recent_short.index[0].date()}")
+        print(f"  Price: ${row['Close']:.2f}")
+        print(f"  Stop Loss: ${row['Stop_Loss_Short']:.2f}")
+        print(f"  Take Profit: ${row['Take_Profit_Short']:.2f}")
+        print(f"  R:R Ratio: {row['RR_Ratio']:.1f}:1")
+
+
+def example_5_backtest_simulation():
+    """Example 5: Simple backtest simulation."""
+    print("\n=== Example 5: Backtest Simulation ===\n")
+
+    strategy = EMACrossoverStrategy()
+
+    ticker = "SPY"
+    data = yf.download(ticker, period="5y", progress=False)
+    signals = strategy.generate_signals(data, ticker=ticker)
+
+    # Extract trades
+    long_signals = signals[signals['Signal_Long']]
+    short_signals = signals[signals['Signal_Short']]
+
+    print(f"Backtest Results for {ticker} (5 years):")
+    print(f"  Total LONG signals: {len(long_signals)}")
+    print(f"  Total SHORT signals: {len(short_signals)}")
+
+    # Calculate simple stats
+    if len(long_signals) > 0:
+        avg_adx = long_signals['ADX'].mean()
+        avg_vol_ratio = long_signals['Volume_Ratio'].mean()
+
+        print(f"\nLONG Signal Statistics:")
+        print(f"  Average ADX: {avg_adx:.1f}")
+        print(f"  Average Volume Ratio: {avg_vol_ratio:.2f}x")
+
+    # Show signal distribution by year
+    all_signals = pd.concat([long_signals, short_signals])
+    if not all_signals.empty:
+        signals_by_year = all_signals.groupby(all_signals.index.year).size()
+        print(f"\nSignals by Year:")
+        for year, count in signals_by_year.items():
+            print(f"  {year}: {count} signals")
+
+
+def example_6_no_filters():
+    """Example 6: Pure EMA crossover (no filters)."""
+    print("\n=== Example 6: Pure EMA Crossover (No Filters) ===\n")
+
+    # Disable all filters
+    strategy = EMACrossoverStrategy(
+        use_volume_filter=False,
+        use_adx_filter=False
+    )
+
+    ticker = "AAPL"
+    data = yf.download(ticker, period="2y", progress=False)
+    signals = strategy.generate_signals(data, ticker=ticker)
+
+    # Count signals
+    total_long = signals['Golden_Cross'].sum()
+    total_short = signals['Death_Cross'].sum()
+
+    print(f"Pure EMA Crossover for {ticker}:")
+    print(f"  Golden Crosses: {total_long}")
+    print(f"  Death Crosses: {total_short}")
+    print(f"  Current Position: {strategy.get_current_position(signals)}")
+
+
+def main():
+    """Run all examples."""
+    examples = [
+        example_1_basic_usage,
+        example_2_market_scan,
+        example_3_custom_parameters,
+        example_4_signal_details,
+        example_5_backtest_simulation,
+        example_6_no_filters,
+    ]
+
+    for example in examples:
+        try:
+            example()
+        except Exception as e:
+            print(f"\n✗ Example failed: {e}")
+            import traceback
+            traceback.print_exc()
+
+        print("\n" + "=" * 70)
+
+
+if __name__ == "__main__":
+    # Run single example
+    # example_1_basic_usage()
+
+    # Or run all examples
+    main()

src/core/monitoring_engine/__init__.py

@@ -0,0 +1,5 @@
+"""Monitoring engine for multi-timeframe price drop detection."""
+
+from .monitoring_service import MonitoringEngineService
+
+__all__ = ["MonitoringEngineService"]

src/core/monitoring_engine/config.py

@@ -0,0 +1,47 @@
+"""Configuration for the monitoring engine."""
+
+from dataclasses import dataclass
+import os
+from typing import List
+
+
+@dataclass
+class MonitoringConfig:
+    """Runtime configuration for monitoring."""
+
+    timeframes_minutes: List[int]
+    sigma_multiplier: float
+    min_alert_gap_minutes: int
+    poll_interval_seconds: int
+    subscriptions_path: str
+
+    alpaca_api_key: str
+    alpaca_api_secret: str
+    alpaca_data_base_url: str
+
+    finnhub_api_key: str
+
+    @classmethod
+    def from_env(cls) -> "MonitoringConfig":
+        timeframes = os.getenv("MONITORING_TIMEFRAMES", "10,30,60,120,180,360,600")
+        timeframes_minutes = [int(x.strip()) for x in timeframes.split(",") if x.strip()]
+
+        sigma_multiplier = float(os.getenv("MONITORING_SIGMA_MULTIPLIER", "3.0"))
+        min_alert_gap_minutes = int(os.getenv("MONITORING_ALERT_GAP_MINUTES", "60"))
+        poll_interval_seconds = int(os.getenv("MONITORING_POLL_INTERVAL_SECONDS", "60"))
+        subscriptions_path = os.getenv(
+            "MONITORING_SUBSCRIPTIONS_PATH",
+            "data/monitoring_subscriptions.json"
+        )
+
+        return cls(
+            timeframes_minutes=timeframes_minutes,
+            sigma_multiplier=sigma_multiplier,
+            min_alert_gap_minutes=min_alert_gap_minutes,
+            poll_interval_seconds=poll_interval_seconds,
+            subscriptions_path=subscriptions_path,
+            alpaca_api_key=os.getenv("ALPACA_API_KEY", ""),
+            alpaca_api_secret=os.getenv("ALPACA_API_SECRET", ""),
+            alpaca_data_base_url=os.getenv("ALPACA_DATA_BASE_URL", ""),
+            finnhub_api_key=os.getenv("FINNHUB_API_TOKEN", "")
+        )

src/core/monitoring_engine/data_sources.py

@@ -0,0 +1,144 @@
+"""Price data sources for monitoring."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Optional
+
+import httpx
+
+from src.telegram_bot.logger import main_logger as logger
+
+
+@dataclass
+class PriceResult:
+    """Price result wrapper."""
+    price: Optional[float]
+    source: str
+    error: Optional[str] = None
+
+
+class BasePriceSource:
+    """Base class for price sources."""
+
+    name: str = "base"
+
+    async def get_price(self, ticker: str) -> PriceResult:
+        raise NotImplementedError
+
+
+class AlpacaPriceSource(BasePriceSource):
+    """Alpaca Data API (REST) price source."""
+
+    name = "alpaca"
+
+    def __init__(self, api_key: str, api_secret: str, base_url: str, http_client: httpx.AsyncClient | None = None):
+        self._api_key = api_key
+        self._api_secret = api_secret
+        self._base_url = base_url.rstrip("/")
+        self._http_client = http_client
+
+    async def get_price(self, ticker: str) -> PriceResult:
+        if not self._api_key or not self._api_secret or not self._base_url:
+            return PriceResult(price=None, source=self.name, error="Missing Alpaca credentials")
+
+        url = f"{self._base_url}/v2/stocks/{ticker}/trades/latest"
+        headers = {
+            "APCA-API-KEY-ID": self._api_key,
+            "APCA-API-SECRET-KEY": self._api_secret
+        }
+
+        client = self._http_client or httpx.AsyncClient(timeout=10.0)
+        close_client = self._http_client is None
+        try:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            payload = response.json()
+            trade = payload.get("trade") or {}
+            price = trade.get("p") or trade.get("price")
+            if price is None:
+                return PriceResult(price=None, source=self.name, error="No price in Alpaca response")
+            return PriceResult(price=float(price), source=self.name)
+        except Exception as exc:
+            return PriceResult(price=None, source=self.name, error=str(exc))
+        finally:
+            if close_client:
+                await client.aclose()
+
+
+class FinnhubPriceSource(BasePriceSource):
+    """Finnhub price source."""
+
+    name = "finnhub"
+
+    def __init__(self, api_key: str):
+        self._api_key = api_key
+
+    async def get_price(self, ticker: str) -> PriceResult:
+        if not self._api_key:
+            return PriceResult(price=None, source=self.name, error="Missing Finnhub API key")
+
+        try:
+            import finnhub
+        except Exception as exc:
+            return PriceResult(price=None, source=self.name, error=f"Finnhub import error: {exc}")
+
+        def _fetch() -> PriceResult:
+            try:
+                client = finnhub.Client(api_key=self._api_key)
+                quote = client.quote(ticker)
+                price = quote.get("c")
+                if price is None:
+                    return PriceResult(price=None, source=self.name, error="No price in Finnhub response")
+                return PriceResult(price=float(price), source=self.name)
+            except Exception as exc:
+                return PriceResult(price=None, source=self.name, error=str(exc))
+
+        return await asyncio.to_thread(_fetch)
+
+
+class YFinancePriceSource(BasePriceSource):
+    """yfinance price source."""
+
+    name = "yfinance"
+
+    async def get_price(self, ticker: str) -> PriceResult:
+        try:
+            import yfinance as yf
+        except Exception as exc:
+            return PriceResult(price=None, source=self.name, error=f"yfinance import error: {exc}")
+
+        def _fetch() -> PriceResult:
+            try:
+                yf_ticker = yf.Ticker(ticker)
+                fast_info = getattr(yf_ticker, "fast_info", None)
+                price = None
+                if fast_info and isinstance(fast_info, dict):
+                    price = fast_info.get("last_price") or fast_info.get("lastPrice")
+                if price is None:
+                    data = yf_ticker.history(period="1d", interval="1m")
+                    if not data.empty:
+                        price = float(data["Close"].iloc[-1])
+                if price is None:
+                    return PriceResult(price=None, source=self.name, error="No price in yfinance response")
+                return PriceResult(price=float(price), source=self.name)
+            except Exception as exc:
+                return PriceResult(price=None, source=self.name, error=str(exc))
+
+        return await asyncio.to_thread(_fetch)
+
+
+class PriceSourceChain:
+    """Chain of price sources with fallback."""
+
+    def __init__(self, sources: list[BasePriceSource]):
+        self._sources = sources
+
+    async def get_price(self, ticker: str) -> PriceResult:
+        for source in self._sources:
+            result = await source.get_price(ticker)
+            if result.price is not None:
+                return result
+            logger.debug(f"Price source {source.name} failed for {ticker}: {result.error}")
+        return PriceResult(price=None, source="none", error="All price sources failed")

src/core/monitoring_engine/monitoring_service.py

@@ -0,0 +1,221 @@
+"""Monitoring service for multi-timeframe price drops with deduplication."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from collections import defaultdict, deque
+from dataclasses import dataclass
+from typing import Callable, Deque, Dict, List, Optional
+
+import numpy as np
+import httpx
+
+from src.telegram_bot.logger import main_logger as logger
+from .config import MonitoringConfig
+from .data_sources import (
+    AlpacaPriceSource,
+    FinnhubPriceSource,
+    YFinancePriceSource,
+    PriceSourceChain,
+    PriceResult
+)
+from .subscriptions import SubscriptionStore
+
+
+@dataclass
+class DropEvent:
+    """Represents a detected drop event."""
+    ticker: str
+    timeframe_minutes: int
+    drop_pct: float
+    threshold_pct: float
+    source: str
+    timestamp: float
+
+
+class MonitoringEngineService:
+    """Service that polls prices, detects drops, and notifies subscribers."""
+
+    def __init__(
+        self,
+        send_alert: Callable[[int, str], asyncio.Future],
+        config: Optional[MonitoringConfig] = None,
+        http_client: httpx.AsyncClient | None = None
+    ):
+        self._config = config or MonitoringConfig.from_env()
+        self._subscription_store = SubscriptionStore(self._config.subscriptions_path)
+        self._http_client = http_client
+
+        self._price_sources = PriceSourceChain([
+            AlpacaPriceSource(
+                api_key=self._config.alpaca_api_key,
+                api_secret=self._config.alpaca_api_secret,
+                base_url=self._config.alpaca_data_base_url,
+                http_client=self._http_client
+            ),
+            FinnhubPriceSource(api_key=self._config.finnhub_api_key),
+            YFinancePriceSource()
+        ])
+
+        self._send_alert = send_alert
+        self._running = False
+        self._task: Optional[asyncio.Task] = None
+
+        self._buffers: Dict[str, Dict[int, Deque[float]]] = defaultdict(dict)
+        self._last_alert_ts: Dict[int, Dict[str, float]] = defaultdict(dict)
+        self._lock = asyncio.Lock()
+
+    # -------------------------
+    # Public API / hooks
+    # -------------------------
+    def subscribe(self, chat_id: int, tickers: List[str]) -> List[str]:
+        """Subscribe chat to tickers."""
+        return self._subscription_store.subscribe(chat_id, tickers)
+
+    def unsubscribe(self, chat_id: int, tickers: List[str]) -> List[str]:
+        """Unsubscribe chat from tickers."""
+        return self._subscription_store.unsubscribe(chat_id, tickers)
+
+    def list_subscriptions(self, chat_id: int) -> List[str]:
+        """List tickers for a chat."""
+        return self._subscription_store.list_tickers(chat_id)
+
+    async def start(self) -> None:
+        """Start background monitoring loop."""
+        if self._running:
+            return
+        self._running = True
+        self._task = asyncio.create_task(self._run_loop())
+        logger.info("Monitoring engine started")
+
+    async def stop(self) -> None:
+        """Stop background monitoring loop."""
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            self._task = None
+        logger.info("Monitoring engine stopped")
+
+    async def process_price(self, ticker: str, price: float, source: str = "external") -> None:
+        """API hook: process external price updates."""
+        async with self._lock:
+            self._update_buffers(ticker, price)
+            events = self._detect_events(ticker, source)
+        await self._dispatch_events(ticker, events)
+
+    # -------------------------
+    # Internal loop
+    # -------------------------
+    async def _run_loop(self) -> None:
+        while self._running:
+            try:
+                await self._scan_once()
+            except Exception as exc:
+                logger.error(f"Monitoring scan failed: {exc}")
+            await asyncio.sleep(self._config.poll_interval_seconds)
+
+    async def _scan_once(self) -> None:
+        subscriptions = self._subscription_store.get_all()
+        tickers = sorted({t for tickers in subscriptions.values() for t in tickers})
+        if not tickers:
+            return
+
+        for ticker in tickers:
+            price_result = await self._price_sources.get_price(ticker)
+            if price_result.price is None:
+                logger.warning(f"Price fetch failed for {ticker}: {price_result.error}")
+                continue
+
+            async with self._lock:
+                self._update_buffers(ticker, price_result.price)
+                events = self._detect_events(ticker, price_result.source)
+
+            await self._dispatch_events(ticker, events)
+
+    # -------------------------
+    # Detection pipeline
+    # -------------------------
+    def _update_buffers(self, ticker: str, price: float) -> None:
+        for tf in self._config.timeframes_minutes:
+            if tf not in self._buffers[ticker]:
+                self._buffers[ticker][tf] = deque(maxlen=tf)
+            self._buffers[ticker][tf].append(price)
+
+    def _detect_events(self, ticker: str, source: str) -> List[DropEvent]:
+        events: List[DropEvent] = []
+        now_ts = time.time()
+        for tf in self._config.timeframes_minutes:
+            window = self._buffers[ticker].get(tf)
+            if not window or len(window) < tf:
+                continue
+            drop_pct = self._compute_drop_pct(window)
+            threshold_pct = self._adaptive_threshold_pct(window)
+            if threshold_pct is None:
+                continue
+            if drop_pct <= threshold_pct:
+                events.append(
+                    DropEvent(
+                        ticker=ticker,
+                        timeframe_minutes=tf,
+                        drop_pct=drop_pct,
+                        threshold_pct=threshold_pct,
+                        source=source,
+                        timestamp=now_ts
+                    )
+                )
+        return events
+
+    def _compute_drop_pct(self, window: Deque[float]) -> float:
+        start_price = window[0]
+        end_price = window[-1]
+        if start_price == 0:
+            return 0.0
+        return ((end_price - start_price) / start_price) * 100.0
+
+    def _adaptive_threshold_pct(self, window: Deque[float]) -> Optional[float]:
+        if len(window) < 5:
+            return None
+        prices = np.array(window, dtype=float)
+        returns = np.diff(prices) / prices[:-1]
+        sigma = float(np.std(returns))
+        if sigma == 0:
+            return None
+        return -self._config.sigma_multiplier * sigma * 100.0
+
+    # -------------------------
+    # Alert dispatch / dedupe
+    # -------------------------
+    async def _dispatch_events(self, ticker: str, events: List[DropEvent]) -> None:
+        if not events:
+            return
+        subscriptions = self._subscription_store.get_all()
+        for chat_id, tickers in subscriptions.items():
+            if ticker not in tickers:
+                continue
+            if self._is_deduped(chat_id, ticker):
+                continue
+            message = self._format_alert_message(ticker, events)
+            await self._send_alert(chat_id, message)
+            self._mark_alert(chat_id, ticker)
+
+    def _is_deduped(self, chat_id: int, ticker: str) -> bool:
+        last_ts = self._last_alert_ts.get(chat_id, {}).get(ticker)
+        if not last_ts:
+            return False
+        gap_seconds = self._config.min_alert_gap_minutes * 60
+        return (time.time() - last_ts) < gap_seconds
+
+    def _mark_alert(self, chat_id: int, ticker: str) -> None:
+        self._last_alert_ts.setdefault(chat_id, {})[ticker] = time.time()
+
+    def _format_alert_message(self, ticker: str, events: List[DropEvent]) -> str:
+        events_sorted = sorted(events, key=lambda e: e.timeframe_minutes)
+        lines = [f"🚨 Drop alert for {ticker}"]
+        lines.append(f"Source: {events_sorted[0].source}")
+        for event in events_sorted:
+            lines.append(
+                f"- {event.timeframe_minutes}m: {event.drop_pct:.2f}% "
+                f"(threshold {event.threshold_pct:.2f}%)"
+            )
+        return "\n".join(lines)

src/core/monitoring_engine/subscriptions.py

@@ -0,0 +1,77 @@
+"""Subscription storage for monitoring alerts."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Dict, List, Set
+
+
+class SubscriptionStore:
+    """Simple JSON-backed subscription store."""
+
+    def __init__(self, path: str):
+        self._path = Path(path)
+        self._subscriptions: Dict[int, Set[str]] = {}
+        self.load()
+
+    def load(self) -> None:
+        """Load subscriptions from disk if present."""
+        if not self._path.exists():
+            self._subscriptions = {}
+            return
+
+        try:
+            data = json.loads(self._path.read_text(encoding="utf-8"))
+            self._subscriptions = {
+                int(chat_id): set(map(str.upper, tickers))
+                for chat_id, tickers in data.items()
+            }
+        except Exception:
+            # If parsing fails, start with empty storage to avoid crashes
+            self._subscriptions = {}
+
+    def save(self) -> None:
+        """Persist subscriptions to disk."""
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        data = {str(chat_id): sorted(list(tickers)) for chat_id, tickers in self._subscriptions.items()}
+        self._path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+    def subscribe(self, chat_id: int, tickers: List[str]) -> List[str]:
+        """Subscribe chat to a list of tickers. Returns added tickers."""
+        norm = [t.strip().upper() for t in tickers if t.strip()]
+        if not norm:
+            return []
+        if chat_id not in self._subscriptions:
+            self._subscriptions[chat_id] = set()
+        before = set(self._subscriptions[chat_id])
+        self._subscriptions[chat_id].update(norm)
+        added = sorted(list(self._subscriptions[chat_id] - before))
+        self.save()
+        return added
+
+    def unsubscribe(self, chat_id: int, tickers: List[str]) -> List[str]:
+        """Unsubscribe chat from tickers. Returns removed tickers."""
+        norm = [t.strip().upper() for t in tickers if t.strip()]
+        if chat_id not in self._subscriptions or not norm:
+            return []
+        before = set(self._subscriptions[chat_id])
+        for t in norm:
+            self._subscriptions[chat_id].discard(t)
+        removed = sorted(list(before - self._subscriptions[chat_id]))
+        if not self._subscriptions[chat_id]:
+            del self._subscriptions[chat_id]
+        self.save()
+        return removed
+
+    def list_tickers(self, chat_id: int) -> List[str]:
+        """Return tickers for a chat."""
+        return sorted(list(self._subscriptions.get(chat_id, set())))
+
+    def get_all(self) -> Dict[int, List[str]]:
+        """Return all subscriptions."""
+        return {chat_id: sorted(list(tickers)) for chat_id, tickers in self._subscriptions.items()}
+
+    def get_chat_ids(self) -> List[int]:
+        """Return all subscribed chat IDs."""
+        return list(self._subscriptions.keys())

src/core/trading/__init__.py

@@ -1,20 +1,28 @@
 """
 Trading Strategy Module
 
-Advanced MACD-based trading system with:
-- Zero-Lag MACD, ATR, ADX, RSI indicators
-- Divergence detection (MACD and RSI)
-- Comprehensive risk management
+Professional trading strategies with risk management:
+
+Strategies:
+- AdvancedMACDStrategy: Zero-Lag MACD with divergence detection
+- EMACrossoverStrategy: Golden Cross / Death Cross (EMA 50/200)
+
+Features:
+- ATR-based stop loss / take profit
+- ADX trend strength filter
+- Volume confirmation
 - Vectorized backtesting
 - Position sizing with Kelly Criterion
 """
 
 from src.core.trading.macd_strategy import AdvancedMACDStrategy
+from src.core.trading.ema_crossover_strategy import EMACrossoverStrategy
 from src.core.trading.backtest_engine import VectorizedBacktest
 from src.core.trading.risk_engine import RiskEngine
 
 __all__ = [
     'AdvancedMACDStrategy',
+    'EMACrossoverStrategy',
     'VectorizedBacktest',
     'RiskEngine',
 ]

src/core/trading/ema_crossover_strategy.py

@@ -0,0 +1,472 @@
+"""
+EMA 50/200 Crossover Strategy (Golden Cross / Death Cross)
+
+Classic trend-following strategy based on exponential moving average crossovers.
+Includes volume, trend strength, and risk management filters.
+"""
+
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+
+
+class EMACrossoverStrategy:
+    """
+    Professional EMA 50/200 crossover strategy with filters.
+
+    Golden Cross: EMA 50 crosses above EMA 200 → BUY signal
+    Death Cross: EMA 50 crosses below EMA 200 → SELL signal
+
+    Features:
+    - Volume confirmation
+    - Trend strength (ADX) filter
+    - ATR-based stop loss / take profit
+    - Cooldown period between trades
+    """
+
+    def __init__(
+        self,
+        fast_ema: int = 50,
+        slow_ema: int = 200,
+        atr_period: int = 14,
+        atr_multiplier_sl: float = 2.0,
+        atr_multiplier_tp: float = 4.0,
+        adx_period: int = 14,
+        adx_threshold: float = 20,
+        volume_period: int = 20,
+        use_volume_filter: bool = True,
+        use_adx_filter: bool = True,
+        cooldown_candles: int = 5
+    ):
+        """
+        Initialize EMA crossover strategy.
+
+        Args:
+            fast_ema: Fast EMA period (default 50)
+            slow_ema: Slow EMA period (default 200)
+            atr_period: ATR period for volatility (default 14)
+            atr_multiplier_sl: ATR multiplier for stop loss (default 2.0)
+            atr_multiplier_tp: ATR multiplier for take profit (default 4.0)
+            adx_period: ADX period for trend strength (default 14)
+            adx_threshold: Minimum ADX for valid signal (default 20)
+            volume_period: Period for average volume (default 20)
+            use_volume_filter: Require above-average volume (default True)
+            use_adx_filter: Require strong trend (default True)
+            cooldown_candles: Minimum bars between trades (default 5)
+        """
+        self.fast_ema = fast_ema
+        self.slow_ema = slow_ema
+        self.atr_period = atr_period
+        self.atr_multiplier_sl = atr_multiplier_sl
+        self.atr_multiplier_tp = atr_multiplier_tp
+        self.adx_period = adx_period
+        self.adx_threshold = adx_threshold
+        self.volume_period = volume_period
+        self.use_volume_filter = use_volume_filter
+        self.use_adx_filter = use_adx_filter
+        self.cooldown_candles = cooldown_candles
+        self.last_trade_idx = {}
+
+    def calculate_ema(self, data: pd.Series, period: int) -> pd.Series:
+        """
+        Calculate Exponential Moving Average.
+
+        Args:
+            data: Price series
+            period: EMA period
+
+        Returns:
+            EMA series
+        """
+        return data.ewm(span=period, adjust=False).mean()
+
+    def calculate_wilder_ema(self, data: pd.Series, period: int) -> pd.Series:
+        """
+        Wilder's EMA (used for ATR and ADX).
+
+        Args:
+            data: Data series
+            period: Smoothing period
+
+        Returns:
+            Smoothed series
+        """
+        alpha = 1.0 / period
+        return data.ewm(alpha=alpha, adjust=False).mean()
+
+    def calculate_atr(self, data: pd.DataFrame) -> pd.Series:
+        """
+        Calculate Average True Range (Wilder's method).
+
+        Args:
+            data: OHLC DataFrame
+
+        Returns:
+            ATR series
+        """
+        high = data['High']
+        low = data['Low']
+        close = data['Close']
+
+        tr1 = high - low
+        tr2 = abs(high - close.shift())
+        tr3 = abs(low - close.shift())
+
+        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+        atr = self.calculate_wilder_ema(tr, self.atr_period)
+
+        return atr
+
+    def calculate_adx(self, data: pd.DataFrame) -> Tuple[pd.Series, pd.Series, pd.Series]:
+        """
+        Calculate Average Directional Index (trend strength).
+
+        Args:
+            data: OHLC DataFrame
+
+        Returns:
+            Tuple of (ADX, +DI, -DI)
+        """
+        high = data['High']
+        low = data['Low']
+        close = data['Close']
+
+        # Directional movement
+        up_move = high.diff()
+        down_move = -low.diff()
+
+        plus_dm = pd.Series(
+            np.where((up_move > down_move) & (up_move > 0), up_move, 0),
+            index=data.index
+        )
+        minus_dm = pd.Series(
+            np.where((down_move > up_move) & (down_move > 0), down_move, 0),
+            index=data.index
+        )
+
+        # True range
+        tr1 = high - low
+        tr2 = abs(high - close.shift())
+        tr3 = abs(low - close.shift())
+        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+
+        # Smooth with Wilder's method
+        atr = self.calculate_wilder_ema(tr, self.adx_period)
+        plus_di_smooth = self.calculate_wilder_ema(plus_dm, self.adx_period)
+        minus_di_smooth = self.calculate_wilder_ema(minus_dm, self.adx_period)
+
+        # Directional indicators
+        plus_di = 100 * plus_di_smooth / atr
+        minus_di = 100 * minus_di_smooth / atr
+
+        # ADX calculation
+        dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di)
+        adx = self.calculate_wilder_ema(dx, self.adx_period)
+
+        return adx, plus_di, minus_di
+
+    def calculate_risk_levels(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Calculate stop loss and take profit levels based on ATR.
+
+        Args:
+            df: DataFrame with ATR calculated
+
+        Returns:
+            DataFrame with risk levels added
+        """
+        # Long positions
+        df['Stop_Loss_Long'] = df['Close'] - self.atr_multiplier_sl * df['ATR']
+        df['Take_Profit_Long'] = df['Close'] + self.atr_multiplier_tp * df['ATR']
+
+        # Short positions
+        df['Stop_Loss_Short'] = df['Close'] + self.atr_multiplier_sl * df['ATR']
+        df['Take_Profit_Short'] = df['Close'] - self.atr_multiplier_tp * df['ATR']
+
+        # Risk-reward ratio
+        df['RR_Ratio'] = self.atr_multiplier_tp / self.atr_multiplier_sl
+
+        return df
+
+    def check_cooldown(self, ticker: str, current_idx: int) -> bool:
+        """
+        Check if enough time has passed since last trade.
+
+        Args:
+            ticker: Ticker symbol
+            current_idx: Current bar index
+
+        Returns:
+            True if cooldown period passed, False otherwise
+        """
+        if ticker not in self.last_trade_idx:
+            return True
+
+        bars_since_last = current_idx - self.last_trade_idx[ticker]
+        return bars_since_last >= self.cooldown_candles
+
+    def generate_signals(
+        self,
+        data: pd.DataFrame,
+        ticker: Optional[str] = None
+    ) -> pd.DataFrame:
+        """
+        Generate trading signals based on EMA crossovers and filters.
+
+        Args:
+            data: OHLC DataFrame with 'Open', 'High', 'Low', 'Close', 'Volume'
+            ticker: Optional ticker symbol for cooldown tracking
+
+        Returns:
+            DataFrame with signals and indicators
+        """
+        df = data.copy()
+
+        # Calculate EMAs
+        df['EMA_Fast'] = self.calculate_ema(df['Close'], self.fast_ema)
+        df['EMA_Slow'] = self.calculate_ema(df['Close'], self.slow_ema)
+
+        # EMA relationship
+        df['EMA_Fast_Above'] = df['EMA_Fast'] > df['EMA_Slow']
+        df['EMA_Fast_Below'] = df['EMA_Fast'] < df['EMA_Slow']
+
+        # Detect crossovers
+        df['Golden_Cross'] = (
+            (df['EMA_Fast'] > df['EMA_Slow']) &
+            (df['EMA_Fast'].shift(1) <= df['EMA_Slow'].shift(1))
+        )
+
+        df['Death_Cross'] = (
+            (df['EMA_Fast'] < df['EMA_Slow']) &
+            (df['EMA_Fast'].shift(1) >= df['EMA_Slow'].shift(1))
+        )
+
+        # Calculate ATR for risk management
+        df['ATR'] = self.calculate_atr(df)
+
+        # Calculate ADX for trend strength (if enabled)
+        if self.use_adx_filter:
+            df['ADX'], df['Plus_DI'], df['Minus_DI'] = self.calculate_adx(df)
+            df['Strong_Trend'] = df['ADX'] > self.adx_threshold
+        else:
+            df['ADX'] = 0
+            df['Plus_DI'] = 0
+            df['Minus_DI'] = 0
+            df['Strong_Trend'] = True
+
+        # Calculate volume filter (if enabled)
+        if self.use_volume_filter:
+            df['Avg_Volume'] = df['Volume'].rolling(window=self.volume_period).mean()
+            df['High_Volume'] = df['Volume'] > df['Avg_Volume']
+        else:
+            df['Avg_Volume'] = df['Volume']
+            df['High_Volume'] = True
+
+        # Additional metrics
+        df['ATR_Pct'] = (df['ATR'] / df['Close']) * 100
+        df['Volume_Ratio'] = df['Volume'] / df['Avg_Volume']
+
+        # EMA distance (% above/below slow EMA)
+        df['EMA_Distance_Pct'] = ((df['Close'] - df['EMA_Slow']) / df['EMA_Slow']) * 100
+
+        # Calculate risk levels
+        df = self.calculate_risk_levels(df)
+
+        # Generate trading signals
+        # LONG: Golden Cross + filters
+        df['Signal_Long'] = (
+            df['Golden_Cross'] &
+            df['Strong_Trend'] &
+            df['High_Volume']
+        )
+
+        # SHORT: Death Cross + filters
+        df['Signal_Short'] = (
+            df['Death_Cross'] &
+            df['Strong_Trend'] &
+            df['High_Volume']
+        )
+
+        # Apply cooldown if ticker specified
+        if ticker is not None:
+            cooldown_mask = pd.Series(False, index=df.index)
+
+            for i in range(len(df)):
+                if df['Signal_Long'].iloc[i] or df['Signal_Short'].iloc[i]:
+                    if not self.check_cooldown(ticker, i):
+                        cooldown_mask.iloc[i] = True
+                    else:
+                        self.last_trade_idx[ticker] = i
+
+            df.loc[cooldown_mask, 'Signal_Long'] = False
+            df.loc[cooldown_mask, 'Signal_Short'] = False
+
+        return df
+
+    def scan_market(
+        self,
+        tickers: List[str],
+        data_loader,
+        period: str = '1y'
+    ) -> pd.DataFrame:
+        """
+        Scan multiple tickers for EMA crossover signals.
+
+        Args:
+            tickers: List of ticker symbols
+            data_loader: Function to load OHLC data (e.g., yfinance)
+            period: Historical period to analyze
+
+        Returns:
+            DataFrame with signals for all tickers
+        """
+        results = []
+
+        for ticker in tickers:
+            try:
+                print(f"Scanning {ticker}...")
+
+                # Load data
+                data = data_loader(ticker, period=period)
+
+                if len(data) < self.slow_ema:
+                    print(f"  ⚠ Insufficient data ({len(data)} bars < {self.slow_ema})")
+                    continue
+
+                # Generate signals
+                df = self.generate_signals(data, ticker=ticker)
+
+                # Check latest signal
+                last_signal_long = df['Signal_Long'].iloc[-1]
+                last_signal_short = df['Signal_Short'].iloc[-1]
+
+                if last_signal_long or last_signal_short:
+                    signal_type = 'LONG' if last_signal_long else 'SHORT'
+
+                    # Calculate entry quality score
+                    quality_score = self._calculate_quality_score(df)
+
+                    results.append({
+                        'Ticker': ticker,
+                        'Signal': signal_type,
+                        'Quality': quality_score,
+                        'Price': round(df['Close'].iloc[-1], 2),
+                        'EMA_Fast': round(df['EMA_Fast'].iloc[-1], 2),
+                        'EMA_Slow': round(df['EMA_Slow'].iloc[-1], 2),
+                        'Stop_Loss': round(
+                            df['Stop_Loss_Long'].iloc[-1] if signal_type == 'LONG'
+                            else df['Stop_Loss_Short'].iloc[-1], 2
+                        ),
+                        'Take_Profit': round(
+                            df['Take_Profit_Long'].iloc[-1] if signal_type == 'LONG'
+                            else df['Take_Profit_Short'].iloc[-1], 2
+                        ),
+                        'RR_Ratio': round(df['RR_Ratio'].iloc[-1], 2),
+                        'ADX': round(df['ADX'].iloc[-1], 2),
+                        'ATR_Pct': round(df['ATR_Pct'].iloc[-1], 2),
+                        'Volume_Ratio': round(df['Volume_Ratio'].iloc[-1], 2),
+                        'EMA_Distance': round(df['EMA_Distance_Pct'].iloc[-1], 2),
+                        'Date': df.index[-1]
+                    })
+
+            except Exception as e:
+                print(f"  ✗ Error analyzing {ticker}: {e}")
+                continue
+
+        if results:
+            result_df = pd.DataFrame(results)
+            # Sort by quality score (descending)
+            result_df = result_df.sort_values('Quality', ascending=False)
+            return result_df
+        else:
+            return pd.DataFrame()
+
+    def _calculate_quality_score(self, df: pd.DataFrame) -> str:
+        """
+        Calculate signal quality based on multiple factors.
+
+        Args:
+            df: DataFrame with indicators
+
+        Returns:
+            Quality rating: 'A', 'B', or 'C'
+        """
+        score = 0
+
+        # Factor 1: ADX strength
+        adx = df['ADX'].iloc[-1]
+        if adx > 30:
+            score += 3
+        elif adx > 25:
+            score += 2
+        elif adx > 20:
+            score += 1
+
+        # Factor 2: Volume confirmation
+        volume_ratio = df['Volume_Ratio'].iloc[-1]
+        if volume_ratio > 1.5:
+            score += 2
+        elif volume_ratio > 1.2:
+            score += 1
+
+        # Factor 3: ATR (volatility - not too high, not too low)
+        atr_pct = df['ATR_Pct'].iloc[-1]
+        if 1.0 <= atr_pct <= 3.0:
+            score += 2  # Ideal volatility range
+        elif 0.5 <= atr_pct <= 5.0:
+            score += 1  # Acceptable range
+
+        # Factor 4: Clean crossover (not too far from EMAs)
+        ema_distance = abs(df['EMA_Distance_Pct'].iloc[-1])
+        if ema_distance < 2.0:
+            score += 2  # Recent crossover
+        elif ema_distance < 5.0:
+            score += 1  # Somewhat recent
+
+        # Convert to letter grade
+        if score >= 7:
+            return 'A'
+        elif score >= 5:
+            return 'B'
+        else:
+            return 'C'
+
+    def get_current_position(self, df: pd.DataFrame) -> str:
+        """
+        Get current position based on EMA alignment.
+
+        Args:
+            df: DataFrame with EMAs
+
+        Returns:
+            'LONG', 'SHORT', or 'NEUTRAL'
+        """
+        if df['EMA_Fast_Above'].iloc[-1]:
+            return 'LONG'
+        elif df['EMA_Fast_Below'].iloc[-1]:
+            return 'SHORT'
+        else:
+            return 'NEUTRAL'
+
+    def get_strategy_description(self) -> str:
+        """Get human-readable strategy description."""
+        return f"""
+EMA {self.fast_ema}/{self.slow_ema} Crossover Strategy
+
+Entry Rules:
+  • LONG: EMA {self.fast_ema} crosses above EMA {self.slow_ema} (Golden Cross)
+  • SHORT: EMA {self.fast_ema} crosses below EMA {self.slow_ema} (Death Cross)
+
+Filters:
+  • ADX: {'Enabled' if self.use_adx_filter else 'Disabled'} (threshold: {self.adx_threshold})
+  • Volume: {'Enabled' if self.use_volume_filter else 'Disabled'} ({self.volume_period}-period average)
+
+Risk Management:
+  • Stop Loss: {self.atr_multiplier_sl}x ATR
+  • Take Profit: {self.atr_multiplier_tp}x ATR
+  • Risk/Reward: {self.atr_multiplier_tp / self.atr_multiplier_sl:.1f}:1
+  • Cooldown: {self.cooldown_candles} candles between trades
+
+ATR Period: {self.atr_period}
+"""

src/telegram_bot/telegram_bot_service.py

@@ -24,6 +24,7 @@ from src.services.async_trading_grid_calculator import generate_grid_message
 from src.core.fundamental_analysis.async_fundamental_analyzer import AsyncFundamentalAnalyzer
 from src.api.insiders.insider_trading_aggregator import InsiderTradingAggregator
 from src.telegram_bot.logger import main_logger as logger
+from src.core.monitoring_engine import MonitoringEngineService
 from src.core.ticker_scanner import TickerAnalyzer
 from src.core.valuation_engine import ValuationEngine
 #from src.core.trading.macd_strategy import AdvancedMACDStrategy
@@ -39,6 +40,7 @@ class TelegramBotService:
         # Trading components (lazy initialized)
         self.live_trader = None
         self.pending_approvals: Dict[str, Any] = {}  # approval_id -> approval data
+        self.monitoring_engine: MonitoringEngineService | None = None
 
     async def initialize(self):
         """Initialize HTTP client"""
@@ -47,14 +49,26 @@ class TelegramBotService:
             limits=httpx.Limits(max_keepalive_connections=5, max_connections=10),
             follow_redirects=True
         )
+        # Initialize monitoring engine with Telegram callback
+        self.monitoring_engine = MonitoringEngineService(
+            send_alert=self._send_monitoring_alert,
+            http_client=self.http_client
+        )
+        await self.monitoring_engine.start()
         main_logger.info("TelegramBotService initialized")
 
     async def cleanup(self):
         """Cleanup resources"""
+        if self.monitoring_engine:
+            await self.monitoring_engine.stop()
         if self.http_client:
             await self.http_client.aclose()
         main_logger.info("TelegramBotService cleaned up")
 
+    async def _send_monitoring_alert(self, chat_id: int, text: str) -> None:
+        """Send monitoring alert to Telegram."""
+        await self.send_message_via_proxy(chat_id, text)
+
     async def send_message_via_proxy(
             self,
             chat_id: int,
@@ -183,6 +197,11 @@ class TelegramBotService:
             response += "/hello - Say hello\n"
             response += "/help - Show help\n"
             response += "/status - Check bot status\n"
+            response += "/monitor_subscribe TICKERS - Subscribe to drop alerts (e.g., /monitor_subscribe AAPL TSLA)\n"
+            response += "/monitor_unsubscribe TICKERS - Unsubscribe from drop alerts\n"
+            response += "/monitor_list - List subscribed tickers\n"
+            response += "/monitor_start - Start monitoring loop\n"
+            response += "/monitor_stop - Stop monitoring loop\n"
             response += "/news - Show all today's news\n"
             response += "/run - News feed analysis by ticker (NVDA)\n\n"
             response += "/pooling - News feed pooling by ticker (NVDA) 🧪 (not working properly, testing)\n\n"
@@ -197,6 +216,11 @@ class TelegramBotService:
             response += "/start or /hello - Get started\n"
             response += "/help - Show this help message\n"
             response += "/status - Check bot status\n\n"
+            response += "/monitor_subscribe TICKERS - Subscribe to drop alerts\n"
+            response += "/monitor_unsubscribe TICKERS - Unsubscribe from drop alerts\n"
+            response += "/monitor_list - List subscribed tickers\n"
+            response += "/monitor_start - Start monitoring loop\n"
+            response += "/monitor_stop - Stop monitoring loop\n\n"
             response += "<b>About:</b>\n"
             response += "This bot provides financial news and sentiment analysis."
             response += "<b>Risk Analysis Commands:</b>\n"
@@ -252,6 +276,57 @@ class TelegramBotService:
             response += "🔧 System: Running on HuggingFace Spaces\n"
             response += "🌐 Proxy: Google Apps Script\n"
             response += "📊 Status: All systems operational"
+        elif base_command == "/monitor_subscribe":
+            if not self.monitoring_engine:
+                response = "❌ Monitoring engine is not initialized."
+            else:
+                tickers = self._parse_tickers(command_parts[1:]) if len(command_parts) > 1 else []
+                if not tickers:
+                    response = "❌ Please provide tickers. Example: /monitor_subscribe AAPL TSLA"
+                else:
+                    added = self.monitoring_engine.subscribe(chat_id, tickers)
+                    if added:
+                        response = f"✅ Subscribed to: {', '.join(added)}"
+                    else:
+                        response = "ℹ️ No new tickers were added."
+
+        elif base_command == "/monitor_unsubscribe":
+            if not self.monitoring_engine:
+                response = "❌ Monitoring engine is not initialized."
+            else:
+                tickers = self._parse_tickers(command_parts[1:]) if len(command_parts) > 1 else []
+                if not tickers:
+                    response = "❌ Please provide tickers. Example: /monitor_unsubscribe AAPL TSLA"
+                else:
+                    removed = self.monitoring_engine.unsubscribe(chat_id, tickers)
+                    if removed:
+                        response = f"✅ Unsubscribed from: {', '.join(removed)}"
+                    else:
+                        response = "ℹ️ No tickers were removed."
+
+        elif base_command == "/monitor_list":
+            if not self.monitoring_engine:
+                response = "❌ Monitoring engine is not initialized."
+            else:
+                tickers = self.monitoring_engine.list_subscriptions(chat_id)
+                if tickers:
+                    response = f"📌 Subscribed tickers: {', '.join(tickers)}"
+                else:
+                    response = "ℹ️ You have no subscriptions yet."
+
+        elif base_command == "/monitor_start":
+            if not self.monitoring_engine:
+                response = "❌ Monitoring engine is not initialized."
+            else:
+                await self.monitoring_engine.start()
+                response = "✅ Monitoring engine started."
+
+        elif base_command == "/monitor_stop":
+            if not self.monitoring_engine:
+                response = "❌ Monitoring engine is not initialized."
+            else:
+                await self.monitoring_engine.stop()
+                response = "✅ Monitoring engine stopped."
 
         elif base_command == "/news":
             await self.news_feed_analysing(chat_id, command, user_name)
@@ -327,6 +402,12 @@ class TelegramBotService:
 
         await self.send_message_via_proxy(chat_id, response)
 
+    def _parse_tickers(self, parts: list[str]) -> list[str]:
+        """Parse tickers from command arguments."""
+        joined = " ".join(parts)
+        raw = [item.strip().upper() for item in joined.replace(",", " ").split()]
+        return [t for t in raw if t]
+
     async def _handle_regular_message(self, chat_id: int, text: str, user_name: str) -> None:
         """Handle regular (non-command) messages"""
         response = f"Hello {user_name}! 👋\n\n"