add fix cache module, add timeframes, etc

src/core/ticker_scanner/core_enums.py

@@ -2,18 +2,30 @@ from enum import Enum
 
 
 class StockExchange(Enum):
+    # American Exchanges
     NYSE = "NYSE"  # New York Stock Exchange
     NASDAQ = "NASDAQ"  # NASDAQ
+    AMEX = "AMEX"  # American Stock Exchange (NYSE American)
+
+    # European Exchanges
     LSE = "LSE"  # London Stock Exchange
+    EURONEXT = "EURONEXT"  # Euronext (Paris, Amsterdam, Brussels)
+    SIX = "SIX"  # Swiss Exchange
+    FWB = "FWB"  # Frankfurt Stock Exchange (Deutsche Börse)
+
+    # Asian Exchanges
     TSE = "TSE"  # Tokyo Stock Exchange
-    SSE = "SSE"  # Shanghai Stock Exchange
     HKEX = "HKEX"  # Hong Kong Stock Exchange
+    SSE = "SSE"  # Shanghai Stock Exchange
     BSE = "BSE"  # Bombay Stock Exchange
     NSE = "NSE"  # National Stock Exchange of India
+
+    # Others
     ASX = "ASX"  # Australian Securities Exchange
     TSX = "TSX"  # Toronto Stock Exchange
-    SIX = "SIX"  # Swiss Exchange
-    FWB = "FWB"  # Frankfurt Stock Exchange
+
+    # Special Categories
+    ETF = "ETF"  # Exchange-Traded Funds
 
 
 class GrowthCategory(Enum):

src/core/ticker_scanner/parallel_data_downloader.py

@@ -40,14 +40,15 @@ def get_cache_stats() -> dict[str, Any]:
     return _cache.get_stats()
 
 
-def fetch_prices(ticker: str, max_retries: int = MAX_RETRIES, use_cache: bool = False) -> Optional[dict[str, Any]]:
+def fetch_prices(ticker: str, max_retries: int = MAX_RETRIES, use_cache: bool = False, period: str = "max") -> Optional[dict[str, Any]]:
     """
-    Download all-time closing prices for a single ticker safely.
+    Download historical closing prices for a single ticker safely.
 
     Args:
         ticker: Stock ticker symbol
         max_retries: Maximum number of retry attempts
         use_cache: Whether to use cached data (NOTE: typically False when called from subprocess)
+        period: Timeframe for historical data (1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max)
 
     Returns:
         dict {'ticker': ticker, 'prices': ndarray, 'dates': DatetimeIndex} or None if failed
@@ -55,7 +56,7 @@ def fetch_prices(ticker: str, max_retries: int = MAX_RETRIES, use_cache: bool =
     # Download fresh data (cache is handled in main process)
     for attempt in range(max_retries):
         try:
-            df = yf.download(ticker, period="max", progress=False, auto_adjust=True)
+            df = yf.download(ticker, period=period, progress=False, auto_adjust=True)
 
             # Handle empty or invalid dataframes
             if df is None or df.empty:
@@ -111,7 +112,8 @@ def batch(iterable: list[str], n: int = BATCH_SIZE):
 
 def download_tickers_parallel(tickers: list[str], exchange: str,
                             max_workers: int = MAX_WORKERS,
-                            use_cache: bool = True) -> list[dict[str, Any]]:
+                            use_cache: bool = True,
+                            period: str = "max") -> list[dict[str, Any]]:
     """
     Download a large list of tickers in parallel batches.
     Uses in-memory cache to avoid re-downloading recently fetched data.
@@ -121,6 +123,7 @@ def download_tickers_parallel(tickers: list[str], exchange: str,
         exchange: Exchange name (e.g., "NASDAQ", "NYSE")
         max_workers: Number of parallel workers
         use_cache: Whether to use cached data
+        period: Timeframe for historical data (1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max)
 
     Returns:
         List of {'ticker': ..., 'prices': ..., 'dates': ...} dicts
@@ -131,14 +134,14 @@ def download_tickers_parallel(tickers: list[str], exchange: str,
 
     if use_cache:
         for ticker in tickers:
-            cached_data = _cache.get(exchange, ticker)
+            cached_data = _cache.get(exchange, ticker, period)
             if cached_data:
                 cached_results.append(cached_data)
             else:
                 tickers_to_download.append(ticker)
 
         if cached_results:
-            logger.info(f"Using cached data for {len(cached_results)} tickers")
+            logger.info(f"Using cached data for {len(cached_results)} tickers (timeframe: {period})")
     else:
         tickers_to_download = tickers
 
@@ -150,7 +153,7 @@ def download_tickers_parallel(tickers: list[str], exchange: str,
         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)
+            results, failed = process_batch(ticker_batch, exchange, max_workers, period)
             all_results.extend(results)
             all_failed.extend(failed)
             # small sleep between batches to reduce rate-limit chance
@@ -162,7 +165,7 @@ def download_tickers_parallel(tickers: list[str], exchange: str,
 
     return all_results
 
-def process_batch(ticker_batch: list[str], exchange: str, max_workers: int) -> 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]]:
     """
     Process a batch of tickers in parallel using multiprocessing.
     Returns tuple (successful_results, failed_tickers)
@@ -171,6 +174,7 @@ def process_batch(ticker_batch: list[str], exchange: str, max_workers: int) -> t
         ticker_batch: List of ticker symbols to process
         exchange: Exchange name for cache key
         max_workers: Number of parallel workers
+        period: Timeframe for historical data (1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max)
 
     Note: Downloads always fetch fresh data (cache checked before this step)
     """
@@ -178,14 +182,14 @@ def process_batch(ticker_batch: list[str], exchange: str, max_workers: int) -> t
     failed = []
     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): t for t in ticker_batch}
+        futures = {executor.submit(fetch_prices, t, use_cache=False, period=period): t for t in ticker_batch}
         for future in as_completed(futures):
             ticker = futures[future]
             try:
                 res = future.result()
                 if res:
                     # Cache the result in the main process after download
-                    _cache.set(exchange, res['ticker'], res)
+                    _cache.set(exchange, res['ticker'], res, period)
                     results.append(res)
                 else:
                     failed.append(ticker)
@@ -195,7 +199,8 @@ def process_batch(ticker_batch: list[str], exchange: str, max_workers: int) -> t
 
 def run_parallel_data_downloader(exchange: StockExchange = StockExchange.NASDAQ,
                                  limit: int = 200,
-                                 use_cache: bool = True) -> list[dict[str, Any]]:
+                                 use_cache: bool = True,
+                                 timeframe: str = "max") -> list[dict[str, Any]]:
     """
     Main function to download ticker data in parallel with caching.
 
@@ -203,6 +208,7 @@ def run_parallel_data_downloader(exchange: StockExchange = StockExchange.NASDAQ,
         exchange: Stock exchange to download from
         limit: Maximum number of tickers to download
         use_cache: Whether to use cached data (expires after 2 hours)
+        timeframe: Historical data timeframe (1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max)
 
     Returns:
         List of dicts with ticker, prices, and dates
@@ -212,10 +218,13 @@ def run_parallel_data_downloader(exchange: StockExchange = StockExchange.NASDAQ,
 
     # Log cache stats
     cache_stats = get_cache_stats()
-    logger.info(f"Cache stats: {cache_stats['valid_cached']} valid, {cache_stats['expired_cached']} expired")
+    logger.info(
+        f"Cache stats: {cache_stats['valid_cached']} valid, {cache_stats['expired_cached']} expired, "
+        f"{cache_stats['size_gb']} GB / {cache_stats['max_size_gb']} GB ({cache_stats['usage_percent']}%)"
+    )
 
-    logger.info(f"Starting download for {len(tickers)} tickers from {exchange.value}...")
-    data = download_tickers_parallel(tickers, exchange.value, use_cache=use_cache)
+    logger.info(f"Starting download for {len(tickers)} tickers from {exchange.value} (timeframe: {timeframe})...")
+    data = download_tickers_parallel(tickers, exchange.value, use_cache=use_cache, period=timeframe)
     logger.info(f"Retrieved {len(data)} tickers successfully")
     return data
 

src/core/ticker_scanner/ticker_analyzer.py

@@ -6,6 +6,8 @@ Coordinates data downloading, growth analysis, ranking, and Telegram notificatio
 from typing import Any
 from datetime import datetime
 
+import yfinance as yf
+
 from src.core.ticker_scanner.core_enums import StockExchange
 from src.core.ticker_scanner.parallel_data_downloader import run_parallel_data_downloader
 from src.core.ticker_scanner.growth_speed_analyzer import GrowthSpeedAnalyzer
@@ -19,7 +21,7 @@ class TickerAnalyzer:
     Manages the complete workflow: download -> analyze -> rank -> notify
     """
 
-    def __init__(self, exchange: str = "NASDAQ", telegram_bot_service=None, limit: int = 200):
+    def __init__(self, exchange: str = "NASDAQ", telegram_bot_service=None, limit: int = 200, timeframe: str = "max"):
         """
         Initialize the analyzer.
 
@@ -27,10 +29,12 @@ class TickerAnalyzer:
             exchange: Stock exchange name (NASDAQ, NYSE, etc.)
             telegram_bot_service: Optional Telegram service for notifications
             limit: Maximum number of tickers to analyze
+            timeframe: Historical data timeframe (1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max)
         """
         self.exchange = StockExchange[exchange]
         self.telegram_bot_service = telegram_bot_service
         self.limit = limit
+        self.timeframe = timeframe
         self.growth_analyzer = GrowthSpeedAnalyzer()
 
     async def run_analysis(self, top_tickers_max_count: int = 10) -> list[dict[str, Any]]:
@@ -43,8 +47,8 @@ class TickerAnalyzer:
         logger.info(f"Starting ticker analysis for {self.exchange.value}")
 
         # Step 1: Download ticker data in parallel
-        logger.info("Step 1: Downloading ticker data...")
-        ticker_data = run_parallel_data_downloader(self.exchange, self.limit)
+        logger.info(f"Step 1: Downloading ticker data (timeframe: {self.timeframe})...")
+        ticker_data = run_parallel_data_downloader(self.exchange, self.limit, timeframe=self.timeframe)
         logger.info(f"Downloaded {len(ticker_data)} tickers")
 
         # Step 2: Analyze growth metrics for each ticker
@@ -156,6 +160,41 @@ class TickerAnalyzer:
         # TODO: Implement actual Telegram sending when chat_id is configured
         # await self.telegram_bot_service.send_message_via_proxy(chat_id, message)
 
+    def _get_market_indicators(self) -> dict[str, Any]:
+        """
+        Fetch real-time market indicators.
+
+        Returns:
+            Dictionary with indicator values and status
+        """
+        indicators = {
+            'vix': None,
+            'vix_status': 'Unknown'
+        }
+
+        try:
+            # Fetch VIX from Yahoo Finance
+            vix_ticker = yf.Ticker("^VIX")
+            vix_data = vix_ticker.history(period="1d")
+
+            if not vix_data.empty:
+                vix_value = vix_data['Close'].iloc[-1]
+                indicators['vix'] = vix_value
+
+                # Classify VIX level
+                if vix_value < 12:
+                    indicators['vix_status'] = '🟢 Low (Complacent)'
+                elif vix_value < 20:
+                    indicators['vix_status'] = '🟡 Normal'
+                elif vix_value < 30:
+                    indicators['vix_status'] = '🟠 Elevated'
+                else:
+                    indicators['vix_status'] = '🔴 High (Fear)'
+        except Exception as e:
+            logger.warning(f"Failed to fetch VIX: {e}")
+
+        return indicators
+
     def _format_telegram_message(self, top_tickers: list[dict[str, Any]]) -> str:
         """
         Format top tickers as a Telegram message with TradingView links.
@@ -169,8 +208,34 @@ class TickerAnalyzer:
         timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
 
         message = f"📊 <b>Top {len(top_tickers)} Growing Tickers - {self.exchange.value}</b>\n"
+        message += f"⏱️ Timeframe: <b>{self.timeframe}</b>\n"
         message += f"🕐 {timestamp}\n\n"
 
+        # Market Indicators Section
+        message += "📈 <b>Market Indicators</b>\n"
+
+        # Get real-time indicators
+        indicators = self._get_market_indicators()
+
+        # VIX
+        if indicators['vix'] is not None:
+            message += f"• <b>VIX:</b> {indicators['vix']:.2f} - {indicators['vix_status']}\n"
+            message += f"  <a href='https://www.tradingview.com/symbols/CBOE-VIX/'>📊 Chart</a>\n"
+        else:
+            message += f"• <b>VIX:</b> <a href='https://www.tradingview.com/symbols/CBOE-VIX/'>📊 Chart</a>\n"
+
+        # Fear & Greed Index
+        message += f"• <b>Fear & Greed:</b> <a href='https://www.feargreedmeter.com/'>📊 Meter</a>\n"
+
+        # FRED Financial Stress Index
+        message += f"• <b>Financial Stress (FRED):</b> <a href='https://www.tradingview.com/symbols/ECONOMICS-STLFSI4/'>📊 STLFSI4</a>\n"
+
+        # CME FedWatch Tool
+        message += f"• <b>Fed Rates (CME):</b> <a href='https://www.cmegroup.com/markets/interest-rates/cme-fedwatch-tool.html'>📊 FedWatch</a>\n\n"
+
+        # Top Tickers
+        message += f"🏆 <b>Top Growing Tickers</b>\n\n"
+
         for i, ticker_data in enumerate(top_tickers, 1):
             ticker = ticker_data['ticker']
             metrics = ticker_data['metrics']
@@ -216,8 +281,28 @@ class TickerAnalyzer:
         """
         # Map exchange enum to TradingView exchange code
         exchange_map = {
+            # American Exchanges
             StockExchange.NASDAQ: "NASDAQ",
             StockExchange.NYSE: "NYSE",
+            StockExchange.AMEX: "AMEX",
+
+            # European Exchanges
+            StockExchange.LSE: "LSE",  # London
+            StockExchange.EURONEXT: "EURONEXT",  # Paris/Amsterdam/Brussels
+            StockExchange.FWB: "FWB",  # Frankfurt
+            StockExchange.SIX: "SIX",  # Swiss
+
+            # Asian Exchanges
+            StockExchange.TSE: "TSE",  # Tokyo
+            StockExchange.HKEX: "HKEX",  # Hong Kong
+            StockExchange.SSE: "SSE",  # Shanghai
+
+            # Others
+            StockExchange.TSX: "TSX",  # Toronto
+            StockExchange.ASX: "ASX",  # Australia
+
+            # Special Categories
+            StockExchange.ETF: "NASDAQ",  # ETFs traded on US exchanges
         }
 
         tv_exchange = exchange_map.get(self.exchange, self.exchange.value)
@@ -242,8 +327,28 @@ class TickerAnalyzer:
         """
         # Map exchange enum to TradingView exchange code
         exchange_map = {
+            # American Exchanges
             StockExchange.NASDAQ: "NASDAQ",
             StockExchange.NYSE: "NYSE",
+            StockExchange.AMEX: "AMEX",
+
+            # European Exchanges
+            StockExchange.LSE: "LSE",  # London
+            StockExchange.EURONEXT: "EURONEXT",  # Paris/Amsterdam/Brussels
+            StockExchange.FWB: "FWB",  # Frankfurt
+            StockExchange.SIX: "SIX",  # Swiss
+
+            # Asian Exchanges
+            StockExchange.TSE: "TSE",  # Tokyo
+            StockExchange.HKEX: "HKEX",  # Hong Kong
+            StockExchange.SSE: "SSE",  # Shanghai
+
+            # Others
+            StockExchange.TSX: "TSX",  # Toronto
+            StockExchange.ASX: "ASX",  # Australia
+
+            # Special Categories
+            StockExchange.ETF: "NASDAQ",  # ETFs traded on US exchanges
         }
 
         tv_exchange = exchange_map.get(self.exchange, self.exchange.value)

src/core/ticker_scanner/ticker_cache.py

@@ -1,70 +1,202 @@
 from typing import Any, Optional
 from datetime import datetime, timedelta
+import sys
 
 from src.telegram_bot.logger import main_logger as logger
 
 
 CACHE_EXPIRY_HOURS = 2          # Cache expiry time in hours
+MAX_CACHE_SIZE_GB = 3           # Maximum cache size in gigabytes
+MAX_CACHE_SIZE_BYTES = MAX_CACHE_SIZE_GB * 1024 * 1024 * 1024  # 3GB in bytes
 
 
 class TickerCache:
     """
-    In-memory cache for ticker data with automatic expiry.
-    Uses exchange:ticker as key to support multiple exchanges.
+    In-memory cache for ticker data with automatic expiry and size limit.
+    Uses exchange:ticker:timeframe as key to support multiple exchanges and timeframes.
+
+    Features:
+    - Time-based expiry (default 2 hours)
+    - Size-based eviction (max 3GB)
+    - LRU (Least Recently Used) eviction policy
     """
 
-    def __init__(self, expiry_hours: int = CACHE_EXPIRY_HOURS):
+    def __init__(self, expiry_hours: int = CACHE_EXPIRY_HOURS, max_size_bytes: int = MAX_CACHE_SIZE_BYTES):
         self._cache: dict[str, dict[str, Any]] = {}
         self._timestamps: dict[str, datetime] = {}
+        self._access_times: dict[str, datetime] = {}  # Track last access for LRU
+        self._entry_sizes: dict[str, int] = {}  # Track size of each entry
+        self._total_size_bytes: int = 0  # Running total of cache size
         self._expiry_hours = expiry_hours
+        self._max_size_bytes = max_size_bytes
+
+    def _make_key(self, exchange: str, ticker: str, timeframe: str = "max") -> str:
+        """Create cache key from exchange, ticker, and timeframe"""
+        return f"{exchange}:{ticker}:{timeframe}"
+
+    def _calculate_size(self, data: dict[str, Any]) -> int:
+        """
+        Calculate approximate size of cached data in bytes.
+
+        This includes the size of:
+        - The ticker string
+        - The prices numpy array
+        - The dates DatetimeIndex
+        """
+        size = 0
+
+        # Size of ticker string
+        size += sys.getsizeof(data.get('ticker', ''))
+
+        # Size of prices array (numpy array has nbytes attribute)
+        prices = data.get('prices')
+        if prices is not None:
+            if hasattr(prices, 'nbytes'):
+                size += prices.nbytes
+            else:
+                size += sys.getsizeof(prices)
+
+        # Size of dates index
+        dates = data.get('dates')
+        if dates is not None:
+            if hasattr(dates, 'nbytes'):
+                size += dates.nbytes
+            else:
+                size += sys.getsizeof(dates)
+
+        # Add overhead for the dict itself
+        size += sys.getsizeof(data)
+
+        return size
+
+    def _evict_lru_entries(self, bytes_needed: int) -> None:
+        """
+        Evict least recently used entries until we have enough space.
+
+        Args:
+            bytes_needed: Number of bytes we need to free up
+        """
+        if not self._access_times:
+            return
+
+        # Sort keys by access time (oldest first)
+        sorted_keys = sorted(self._access_times.keys(), key=lambda k: self._access_times[k])
 
-    def _make_key(self, exchange: str, ticker: str) -> str:
-        """Create cache key from exchange and ticker"""
-        return f"{exchange}:{ticker}"
+        bytes_freed = 0
+        evicted_count = 0
 
-    def is_valid(self, exchange: str, ticker: str) -> bool:
+        for key in sorted_keys:
+            if bytes_freed >= bytes_needed:
+                break
+
+            # Remove this entry
+            if key in self._cache:
+                entry_size = self._entry_sizes.get(key, 0)
+
+                del self._cache[key]
+                del self._timestamps[key]
+                del self._access_times[key]
+                del self._entry_sizes[key]
+
+                self._total_size_bytes -= entry_size
+                bytes_freed += entry_size
+                evicted_count += 1
+
+        if evicted_count > 0:
+            logger.info(f"Evicted {evicted_count} LRU entries, freed {bytes_freed / (1024**2):.2f} MB")
+
+    def is_valid(self, exchange: str, ticker: str, timeframe: str = "max") -> bool:
         """Check if cached data is still valid (not expired)"""
-        key = self._make_key(exchange, ticker)
+        key = self._make_key(exchange, ticker, timeframe)
         if key not in self._timestamps:
             return False
 
         cache_age = datetime.now() - self._timestamps[key]
         return cache_age < timedelta(hours=self._expiry_hours)
 
-    def get(self, exchange: str, ticker: str) -> Optional[dict[str, Any]]:
-        """Get cached data if valid, None otherwise"""
-        if self.is_valid(exchange, ticker):
-            key = self._make_key(exchange, ticker)
+    def get(self, exchange: str, ticker: str, timeframe: str = "max") -> Optional[dict[str, Any]]:
+        """
+        Get cached data if valid, None otherwise.
+        Updates access time for LRU tracking.
+        """
+        if self.is_valid(exchange, ticker, timeframe):
+            key = self._make_key(exchange, ticker, timeframe)
+            # Update access time for LRU
+            self._access_times[key] = datetime.now()
             logger.debug(f"Using cached data for {key}")
             return self._cache.get(key)
         return None
 
-    def set(self, exchange: str, ticker: str, data: dict[str, Any]) -> None:
-        """Cache ticker data with timestamp"""
-        key = self._make_key(exchange, ticker)
+    def set(self, exchange: str, ticker: str, data: dict[str, Any], timeframe: str = "max") -> None:
+        """
+        Cache ticker data with timestamp and size tracking.
+        Evicts LRU entries if cache size limit would be exceeded.
+        """
+        key = self._make_key(exchange, ticker, timeframe)
+
+        # Calculate size of new data
+        new_entry_size = self._calculate_size(data)
+
+        # If updating existing entry, account for old size
+        old_entry_size = 0
+        if key in self._cache:
+            old_entry_size = self._entry_sizes.get(key, 0)
+            self._total_size_bytes -= old_entry_size
+
+        # Check if we need to evict entries
+        size_after_add = self._total_size_bytes + new_entry_size
+        if size_after_add > self._max_size_bytes:
+            bytes_to_free = size_after_add - self._max_size_bytes
+            logger.warning(
+                f"Cache size would exceed limit ({size_after_add / (1024**3):.2f} GB > "
+                f"{self._max_size_bytes / (1024**3):.2f} GB). Evicting LRU entries..."
+            )
+            self._evict_lru_entries(bytes_to_free)
+
+        # Add/update entry
         self._cache[key] = data
         self._timestamps[key] = datetime.now()
-        logger.debug(f"Cached data for {key}")
+        self._access_times[key] = datetime.now()
+        self._entry_sizes[key] = new_entry_size
+        self._total_size_bytes += new_entry_size
+
+        logger.debug(
+            f"Cached data for {key} (size: {new_entry_size / (1024**2):.2f} MB, "
+            f"total cache: {self._total_size_bytes / (1024**3):.2f} GB)"
+        )
 
     def clear(self) -> None:
-        """Clear all cached data"""
+        """Clear all cached data and reset size tracking"""
         self._cache.clear()
         self._timestamps.clear()
+        self._access_times.clear()
+        self._entry_sizes.clear()
+        self._total_size_bytes = 0
         logger.info("Cache cleared")
 
     def get_stats(self) -> dict[str, Any]:
-        """Get cache statistics"""
+        """
+        Get comprehensive cache statistics including size information.
+
+        Returns:
+            Dictionary with cache stats including entry counts and memory usage
+        """
         valid_count = 0
         for key in self._cache.keys():
-            # Parse key to get exchange and ticker
-            parts = key.split(':', 1)
-            if len(parts) == 2:
-                exchange, ticker = parts
-                if self.is_valid(exchange, ticker):
+            # Parse key to get exchange, ticker, and timeframe
+            parts = key.split(':')
+            if len(parts) == 3:
+                exchange, ticker, timeframe = parts
+                if self.is_valid(exchange, ticker, timeframe):
                     valid_count += 1
 
         return {
             'total_cached': len(self._cache),
             'valid_cached': valid_count,
-            'expired_cached': len(self._cache) - valid_count
+            'expired_cached': len(self._cache) - valid_count,
+            'size_bytes': self._total_size_bytes,
+            'size_mb': round(self._total_size_bytes / (1024**2), 2),
+            'size_gb': round(self._total_size_bytes / (1024**3), 3),
+            'max_size_gb': self._max_size_bytes / (1024**3),
+            'usage_percent': round((self._total_size_bytes / self._max_size_bytes) * 100, 1) if self._max_size_bytes > 0 else 0
         }

src/core/ticker_scanner/ticker_lists/__init__.py

@@ -0,0 +1,28 @@
+"""
+Ticker Lists Module
+Organized ticker lists for various global stock exchanges and commodities
+"""
+
+from src.core.ticker_scanner.ticker_lists.nasdaq import NASDAQ_TICKERS
+from src.core.ticker_scanner.ticker_lists.nyse import NYSE_TICKERS
+from src.core.ticker_scanner.ticker_lists.lse import LSE_TICKERS
+from src.core.ticker_scanner.ticker_lists.amex import AMEX_TICKERS
+from src.core.ticker_scanner.ticker_lists.tse import TSE_TICKERS
+from src.core.ticker_scanner.ticker_lists.hkex import HKEX_TICKERS
+from src.core.ticker_scanner.ticker_lists.tsx import TSX_TICKERS
+from src.core.ticker_scanner.ticker_lists.euronext import EURONEXT_TICKERS
+from src.core.ticker_scanner.ticker_lists.commodities import COMMODITIES_TICKERS
+from src.core.ticker_scanner.ticker_lists.etf import ETF_TICKERS
+
+__all__ = [
+    'NASDAQ_TICKERS',
+    'NYSE_TICKERS',
+    'LSE_TICKERS',
+    'AMEX_TICKERS',
+    'TSE_TICKERS',
+    'HKEX_TICKERS',
+    'TSX_TICKERS',
+    'EURONEXT_TICKERS',
+    'COMMODITIES_TICKERS',
+    'ETF_TICKERS',
+]

src/core/ticker_scanner/ticker_lists/amex.py

@@ -0,0 +1,12 @@
+"""
+AMEX (American Stock Exchange / NYSE American) - Popular Tickers
+Curated list of top AMEX-listed securities (mostly ETFs)
+"""
+
+AMEX_TICKERS = [
+    "SPY", "QQQ", "IWM", "DIA", "VXX", "GLD", "SLV", "XLF",
+    "EEM", "XLE", "XLK", "XLP", "XLI", "XLV", "XLU", "XLY",
+    "VTI", "EFA", "HYG", "LQD", "TLT", "AGG", "GDX", "SH",
+    "EWJ", "FXI", "EWZ", "RSX", "TBT", "UNG", "USO", "VEA",
+    "IYR", "XOP", "XME", "ITB", "XHB", "KRE", "XRT", "IBB"
+]

src/core/ticker_scanner/ticker_lists/commodities.py

@@ -0,0 +1,39 @@
+"""
+Commodities & ETFs - Popular Tickers
+Curated list of commodity ETFs, forex commodity symbols, sector funds, and crypto-related tickers
+Traded on NYSE/NASDAQ/AMEX and Forex markets
+"""
+
+COMMODITIES_TICKERS = [
+    # Forex - Precious Metals (spot prices)
+    "XAUUSD",  # Gold/USD
+    "XAGUSD",  # Silver/USD
+    "XPTUSD",  # Platinum/USD
+    "XPDUSD",  # Palladium/USD
+
+    # Forex - Energy
+    "XBRUSD",  # Brent Crude Oil/USD
+    "XTIUSD",  # WTI Crude Oil/USD
+    "XNGUSD",  # Natural Gas/USD
+
+    # Forex - Industrial Metals
+    "XCUUSD",  # Copper/USD
+
+    # ETFs - Precious Metals
+    "GLD", "SLV", "PPLT", "PALL", "IAU", "PHYS", "PSLV",
+
+    # ETFs - Energy
+    "USO", "UNG", "BNO", "UGA", "OIL", "XLE", "XES",
+
+    # ETFs - Agriculture
+    "CORN", "WEAT", "SOYB", "DBA", "JJG", "JO", "NIB",
+
+    # ETFs - Industrial Metals
+    "CPER", "JJC", "DBB", "JJN", "LD", "JJT",
+
+    # ETFs - Broad Commodities
+    "DBC", "GSG", "COMT", "PDBC", "GCC", "DJP",
+
+    # Crypto-related
+    "GBTC", "ETHE", "BITO", "BTF", "IBIT"
+]

src/core/ticker_scanner/ticker_lists/etf.py

@@ -0,0 +1,129 @@
+"""
+ETFs (Exchange-Traded Funds) - Popular Tickers
+Curated list of top ETFs across various categories
+Traded on NYSE/NASDAQ/AMEX
+"""
+
+ETF_TICKERS = [
+    # Major Index ETFs
+    "SPY",   # SPDR S&P 500
+    "QQQ",   # Invesco QQQ (NASDAQ-100)
+    "DIA",   # SPDR Dow Jones
+    "IWM",   # iShares Russell 2000
+    "VTI",   # Vanguard Total Stock Market
+    "VOO",   # Vanguard S&P 500
+    "VEA",   # Vanguard FTSE Developed Markets
+    "VWO",   # Vanguard FTSE Emerging Markets
+    "EFA",   # iShares MSCI EAFE
+    "EEM",   # iShares MSCI Emerging Markets
+
+    # Technology Sector
+    "XLK",   # Technology Select Sector SPDR
+    "VGT",   # Vanguard Information Technology
+    "ARKK",  # ARK Innovation
+    "ARKW",  # ARK Next Generation Internet
+    "ARKG",  # ARK Genomic Revolution
+    "ARKF",  # ARK Fintech Innovation
+    "IGV",   # iShares Expanded Tech-Software
+    "SOXX",  # iShares Semiconductor
+    "SMH",   # VanEck Semiconductor
+
+    # Financial Sector
+    "XLF",   # Financial Select Sector SPDR
+    "VFH",   # Vanguard Financials
+    "KRE",   # SPDR S&P Regional Banking
+    "KBE",   # SPDR S&P Bank
+
+    # Healthcare Sector
+    "XLV",   # Health Care Select Sector SPDR
+    "VHT",   # Vanguard Health Care
+    "IBB",   # iShares Biotechnology
+    "XBI",   # SPDR S&P Biotech
+
+    # Energy Sector
+    "XLE",   # Energy Select Sector SPDR
+    "VDE",   # Vanguard Energy
+    "XES",   # SPDR S&P Oil & Gas Exploration
+
+    # Consumer Sectors
+    "XLY",   # Consumer Discretionary SPDR
+    "XLP",   # Consumer Staples SPDR
+    "VCR",   # Vanguard Consumer Discretionary
+    "VDC",   # Vanguard Consumer Staples
+
+    # Industrial Sector
+    "XLI",   # Industrial Select Sector SPDR
+    "VIS",   # Vanguard Industrials
+
+    # Real Estate
+    "VNQ",   # Vanguard Real Estate
+    "IYR",   # iShares U.S. Real Estate
+    "XLRE",  # Real Estate Select Sector SPDR
+
+    # Utilities
+    "XLU",   # Utilities Select Sector SPDR
+    "VPU",   # Vanguard Utilities
+
+    # Materials
+    "XLB",   # Materials Select Sector SPDR
+    "VAW",   # Vanguard Materials
+
+    # Communications
+    "XLC",   # Communication Services SPDR
+    "VOX",   # Vanguard Communication Services
+
+    # Bond ETFs
+    "AGG",   # iShares Core U.S. Aggregate Bond
+    "BND",   # Vanguard Total Bond Market
+    "TLT",   # iShares 20+ Year Treasury Bond
+    "IEF",   # iShares 7-10 Year Treasury Bond
+    "SHY",   # iShares 1-3 Year Treasury Bond
+    "LQD",   # iShares iBoxx Investment Grade Corporate
+    "HYG",   # iShares iBoxx High Yield Corporate
+    "JNK",   # SPDR Bloomberg High Yield Bond
+    "TIP",   # iShares TIPS Bond
+    "MUB",   # iShares National Muni Bond
+
+    # Commodity ETFs
+    "GLD",   # SPDR Gold Shares
+    "SLV",   # iShares Silver Trust
+    "USO",   # United States Oil Fund
+    "UNG",   # United States Natural Gas Fund
+    "DBC",   # Invesco DB Commodity Index
+    "PDBC",  # Invesco Optimum Yield Diversified Commodity
+
+    # Volatility
+    "VXX",   # iPath Series B S&P 500 VIX Short-Term
+    "UVXY",  # ProShares Ultra VIX Short-Term
+
+    # International
+    "IXUS",  # iShares Core MSCI Total International
+    "VXUS",  # Vanguard Total International Stock
+    "IEFA",  # iShares Core MSCI EAFE
+    "IEMG",  # iShares Core MSCI Emerging Markets
+
+    # Thematic/Growth
+    "ICLN",  # iShares Global Clean Energy
+    "TAN",   # Invesco Solar
+    "LIT",   # Global X Lithium & Battery Tech
+    "BOTZ",  # Global X Robotics & AI
+    "FINX",  # Global X FinTech
+    "CLOU",  # Global X Cloud Computing
+    "HACK",  # ETFMG Prime Cyber Security
+    "BETZ",  # Roundhill Sports Betting & iGaming
+
+    # Leveraged/Inverse (use with caution)
+    "TQQQ",  # ProShares UltraPro QQQ
+    "SQQQ",  # ProShares UltraPro Short QQQ
+    "SPXU",  # ProShares UltraPro Short S&P500
+    "UPRO",  # ProShares UltraPro S&P500
+    "TNA",   # Direxion Daily Small Cap Bull 3X
+    "TZA",   # Direxion Daily Small Cap Bear 3X
+
+    # Dividend ETFs
+    "SCHD",  # Schwab U.S. Dividend Equity
+    "VYM",   # Vanguard High Dividend Yield
+    "DVY",   # iShares Select Dividend
+    "NOBL",  # ProShares S&P 500 Dividend Aristocrats
+    "VIG",   # Vanguard Dividend Appreciation
+]

src/core/ticker_scanner/ticker_lists/euronext.py

@@ -0,0 +1,15 @@
+"""
+Euronext (Paris, Amsterdam, Brussels) - Popular Tickers
+Curated list of top Euronext-listed stocks
+Note: Suffixes - .PA (Paris), .AS (Amsterdam), .BR (Brussels)
+"""
+
+EURONEXT_TICKERS = [
+    # Paris (PA)
+    "MC.PA", "OR.PA", "SAN.PA", "AIR.PA", "BNP.PA", "TTE.PA", "SU.PA", "SAF.PA",
+    "CS.PA", "GLE.PA", "RMS.PA", "CAP.PA", "ACA.PA", "VIV.PA", "DG.PA", "EN.PA",
+    # Amsterdam (AS)
+    "ASML.AS", "ADYEN.AS", "HEIA.AS", "INGA.AS", "ABN.AS", "PHIA.AS", "KPN.AS", "MT.AS",
+    # Brussels (BR)
+    "ABI.BR", "KBC.BR", "ACKB.BR", "UCB.BR", "COFB.BR", "SOF.BR", "SOLB.BR", "GLPG.BR"
+]

src/core/ticker_scanner/ticker_lists/hkex.py

@@ -0,0 +1,12 @@
+"""
+HKEX (Hong Kong Stock Exchange) - Popular Tickers
+Curated list of top HKEX-listed stocks
+Note: HKEX tickers end with .HK suffix for Yahoo Finance
+"""
+
+HKEX_TICKERS = [
+    "0700.HK", "9988.HK", "0939.HK", "0941.HK", "1299.HK", "0005.HK", "3690.HK", "2318.HK",
+    "1398.HK", "3988.HK", "0388.HK", "1211.HK", "0883.HK", "0001.HK", "0002.HK", "0003.HK",
+    "2382.HK", "9618.HK", "1810.HK", "2020.HK", "9999.HK", "1093.HK", "0016.HK", "0011.HK",
+    "1113.HK", "0688.HK", "0012.HK", "2269.HK", "1024.HK", "2628.HK", "1109.HK", "0968.HK"
+]

src/core/ticker_scanner/ticker_lists/lse.py

@@ -0,0 +1,14 @@
+"""
+LSE (London Stock Exchange) - Popular Tickers
+Curated list of top LSE-listed stocks
+Note: LSE tickers end with .L suffix for Yahoo Finance
+"""
+
+LSE_TICKERS = [
+    "SHEL.L", "AZN.L", "HSBA.L", "BP.L", "ULVR.L", "DGE.L", "GSK.L", "RIO.L",
+    "REL.L", "NG.L", "BARC.L", "VOD.L", "LSEG.L", "PRU.L", "BT-A.L", "LLOY.L",
+    "AAL.L", "GLEN.L", "BA.L", "CRH.L", "IMB.L", "EXPN.L", "RKT.L", "ANTO.L",
+    "AUTO.L", "FRES.L", "III.L", "SBRY.L", "WPP.L", "MNG.L", "OCDO.L", "BHP.L",
+    "STAN.L", "CPG.L", "LGEN.L", "RMV.L", "BATS.L", "RTO.L", "INF.L", "NWG.L",
+    "SSE.L", "SGE.L", "SMDS.L", "SMT.L", "SMIN.L", "BNZL.L", "LAND.L", "PSN.L"
+]

src/core/ticker_scanner/ticker_lists/nasdaq.py

@@ -0,0 +1,19 @@
+"""
+NASDAQ Stock Exchange - Popular Tickers
+Curated list of top NASDAQ-listed stocks
+"""
+
+NASDAQ_TICKERS = [
+    "AAPL", "MSFT", "GOOGL", "GOOG", "AMZN", "NVDA", "META", "TSLA",
+    "AVGO", "ASML", "COST", "NFLX", "AMD", "PEP", "ADBE", "CSCO",
+    "CMCSA", "INTC", "TMUS", "INTU", "TXN", "QCOM", "AMGN", "HON",
+    "AMAT", "SBUX", "BKNG", "MDLZ", "ADI", "GILD", "ISRG", "VRTX",
+    "REGN", "LRCX", "ADP", "PANW", "MU", "PYPL", "MELI", "SNPS",
+    "KLAC", "CDNS", "MAR", "ABNB", "CTAS", "ORLY", "MRVL", "NXPI",
+    "CRWD", "FTNT", "CSX", "ADSK", "MNST", "DXCM", "WDAY", "AZN",
+    "PCAR", "ROP", "PAYX", "ROST", "CPRT", "FAST", "ODFL", "CTSH",
+    "EA", "VRSK", "CHTR", "CSGP", "GEHC", "BKR", "XEL", "TEAM",
+    "IDXX", "DASH", "ON", "LULU", "KDP", "ANSS", "ZS", "FANG",
+    "MCHP", "TTWO", "BIIB", "DDOG", "CDW", "ALGN", "ILMN", "WBD",
+    "MRNA", "GFS", "SMCI", "WBA", "ZM", "RIVN", "LCID", "PLUG"
+]

src/core/ticker_scanner/ticker_lists/nyse.py

@@ -0,0 +1,17 @@
+"""
+NYSE (New York Stock Exchange) - Popular Tickers
+Curated list of top NYSE-listed stocks
+"""
+
+NYSE_TICKERS = [
+    "BRK.B", "UNH", "JNJ", "XOM", "JPM", "V", "PG", "MA", "HD", "CVX",
+    "MRK", "ABBV", "KO", "LLY", "BAC", "PFE", "WMT", "TMO", "DIS", "ABT",
+    "CRM", "ACN", "VZ", "ORCL", "NKE", "MCD", "ADBE", "DHR", "PM", "NEE",
+    "CSCO", "WFC", "TXN", "BMY", "UPS", "RTX", "LOW", "MS", "SPGI", "HON",
+    "UNP", "QCOM", "T", "GS", "ELV", "INTU", "CAT", "IBM", "DE", "AMGN",
+    "BA", "BLK", "AXP", "PLD", "GILD", "SBUX", "ADI", "MDLZ", "GE", "ISRG",
+    "C", "BKNG", "TJX", "VRTX", "CB", "MMC", "SYK", "AMT", "REGN", "CI",
+    "LRCX", "ADP", "SO", "DUK", "ZTS", "MO", "PGR", "FI", "SCHW", "BSX",
+    "ITW", "EOG", "SLB", "MMM", "APD", "CL", "BDX", "TGT", "USB", "NOC",
+    "HUM", "AON", "EMR", "ICE", "PNC", "CME", "ETN", "SHW", "MCO", "FCX"
+]

src/core/ticker_scanner/ticker_lists/tse.py

@@ -0,0 +1,12 @@
+"""
+TSE (Tokyo Stock Exchange) - Popular Tickers
+Curated list of top TSE-listed stocks (Japan)
+Note: TSE tickers end with .T suffix for Yahoo Finance
+"""
+
+TSE_TICKERS = [
+    "7203.T", "6758.T", "9984.T", "8306.T", "9432.T", "6861.T", "7267.T", "8035.T",
+    "6902.T", "8316.T", "4502.T", "4503.T", "6501.T", "8058.T", "9433.T", "6752.T",
+    "8001.T", "5401.T", "7974.T", "7751.T", "6954.T", "4519.T", "8031.T", "8766.T",
+    "6367.T", "4661.T", "2914.T", "9022.T", "4568.T", "6273.T", "6971.T", "6594.T"
+]

src/core/ticker_scanner/ticker_lists/tsx.py

@@ -0,0 +1,12 @@
+"""
+TSX (Toronto Stock Exchange) - Popular Tickers
+Curated list of top TSX-listed stocks (Canada)
+Note: TSX tickers end with .TO suffix for Yahoo Finance
+"""
+
+TSX_TICKERS = [
+    "SHOP.TO", "RY.TO", "TD.TO", "ENB.TO", "BNS.TO", "BMO.TO", "CNR.TO", "CNQ.TO",
+    "CP.TO", "TRI.TO", "WCN.TO", "SU.TO", "ABX.TO", "MFC.TO", "BCE.TO", "CVE.TO",
+    "CM.TO", "ATD.TO", "L.TO", "FNV.TO", "NTR.TO", "TRP.TO", "IMO.TO", "BAM.TO",
+    "QSR.TO", "WN.TO", "SLF.TO", "CSU.TO", "MG.TO", "GIB-A.TO", "FSV.TO", "PPL.TO"
+]

src/core/ticker_scanner/tickers_provider.py

@@ -4,113 +4,180 @@ from io import StringIO
 
 from src.core.ticker_scanner.core_enums import StockExchange
 from src.telegram_bot.logger import main_logger as logger
+from src.core.ticker_scanner.ticker_lists import (
+    NASDAQ_TICKERS,
+    NYSE_TICKERS,
+    LSE_TICKERS,
+    AMEX_TICKERS,
+    TSE_TICKERS,
+    HKEX_TICKERS,
+    TSX_TICKERS,
+    EURONEXT_TICKERS,
+    COMMODITIES_TICKERS,
+    ETF_TICKERS,
+)
 
 
-'''
 class TickersProvider:
+    """
+    Provides ticker lists for various global stock exchanges.
+    Only returns curated/popular lists (no full lists from external sources).
+    """
+
+    NASDAQ_POPULAR = NASDAQ_TICKERS
+    NYSE_POPULAR = NYSE_TICKERS
+    LSE_POPULAR = LSE_TICKERS
+    AMEX_POPULAR = AMEX_TICKERS
+    TSE_POPULAR = TSE_TICKERS
+    HKEX_POPULAR = HKEX_TICKERS
+    TSX_POPULAR = TSX_TICKERS
+    EURONEXT_POPULAR = EURONEXT_TICKERS
+    COMMODITIES_POPULAR = COMMODITIES_TICKERS
+    ETF_POPULAR = ETF_TICKERS
+
     def load_active_nasdaq_tickers(self) -> list[str]:
-        url = "ftp://ftp.nasdaqtrader.com/SymbolDirectory/nasdaqtraded.txt"
-        df = pd.read_csv(url, sep="|")
-        # Keep only active tickers (Test Issue == 'N')
-        df_active = df[df["Test Issue"] == "N"]
-        tickers = df_active["NASDAQ Symbol"].tolist()
-        return tickers
+        """Load NASDAQ tickers from API, fallback to curated list"""
+        try:
+            url = "https://api.nasdaq.com/api/screener/stocks?exchange=nasdaq"
+            headers = {"User-Agent": "Mozilla/5.0"}
+            resp = requests.get(url, headers=headers, timeout=10)
+            resp.raise_for_status()
+            data = resp.json()
+            tickers = [row["symbol"] for row in data["data"]["rows"]]
+            logger.info(f"Loaded {len(tickers)} NASDAQ tickers from API")
+            return tickers
+        except Exception as e:
+            logger.warning(f"Failed to load NASDAQ tickers from API: {e}")
+            return self.NASDAQ_POPULAR.copy()
 
     def load_active_nyse_tickers(self) -> list[str]:
-        url = "https://eodhistoricaldata.com/api/exchange-symbol-list/NYSE.csv"
-        df = pd.read_csv(url)
-        # Keep only active, common stocks
-        df_active = df[(df['Type'] == 'Common Stock') & (df['Delisted'] != 1)]
-        tickers = df_active['Code'].tolist()
-        return tickers
+        """Load NYSE tickers from API, fallback to curated list"""
+        try:
+            url = "https://api.nasdaq.com/api/screener/stocks?exchange=nyse"
+            headers = {"User-Agent": "Mozilla/5.0"}
+            resp = requests.get(url, headers=headers, timeout=10)
+            resp.raise_for_status()
+            data = resp.json()
+            tickers = [row["symbol"] for row in data["data"]["rows"]]
+            logger.info(f"Loaded {len(tickers)} NYSE tickers from API")
+            return tickers
+        except Exception as e:
+            logger.warning(f"Failed to load NYSE tickers from API: {e}")
+            return self.NYSE_POPULAR.copy()
 
-    def get_tickers(self, exchange: StockExchange) -> list[str]:
-        logger.info(f"Fetching tickers for {exchange.value}")
-        if exchange == exchange.NASDAQ:
-            tickers = self.load_active_nasdaq_tickers()
-        elif exchange == exchange.NYSE:
-            tickers = self.load_active_nyse_tickers()
-        else:
-            tickers = []
-        logger.info(f"Found {len(tickers)} tickers for {exchange.value}")
-        return tickers
-'''
+    def load_active_lse_tickers(self) -> list[str]:
+        """Load LSE tickers from API, fallback to curated list"""
+        try:
+            url = "https://www.londonstockexchange.com/api/v1/symbols"
+            resp = requests.get(url, timeout=10)
+            resp.raise_for_status()
+            data = resp.json()
+            tickers = [item["symbol"] for item in data["symbols"]]
+            logger.info(f"Loaded {len(tickers)} LSE tickers from API")
+            return tickers
+        except Exception as e:
+            logger.warning(f"Failed to load LSE tickers from API: {e}")
+            return self.LSE_POPULAR.copy()
 
+    def load_active_amex_tickers(self) -> list[str]:
+        """Load AMEX tickers from API, fallback to curated list"""
+        try:
+            url = "https://api.nasdaq.com/api/screener/stocks?exchange=amex"
+            headers = {"User-Agent": "Mozilla/5.0"}
+            resp = requests.get(url, headers=headers, timeout=10)
+            resp.raise_for_status()
+            data = resp.json()
+            tickers = [row["symbol"] for row in data["data"]["rows"]]
+            logger.info(f"Loaded {len(tickers)} AMEX tickers from API")
+            return tickers
+        except Exception as e:
+            logger.warning(f"Failed to load AMEX tickers from API: {e}")
+            return self.AMEX_POPULAR.copy()
 
-class TickersProvider:
-    # Fallback list of popular NASDAQ tickers
-    NASDAQ_POPULAR = [
-        "AAPL", "MSFT", "GOOGL", "GOOG", "AMZN", "NVDA", "META", "TSLA",
-        "AVGO", "ASML", "COST", "NFLX", "AMD", "PEP", "ADBE", "CSCO",
-        "CMCSA", "INTC", "TMUS", "INTU", "TXN", "QCOM", "AMGN", "HON",
-        "AMAT", "SBUX", "BKNG", "MDLZ", "ADI", "GILD", "ISRG", "VRTX",
-        "REGN", "LRCX", "ADP", "PANW", "MU", "PYPL", "MELI", "SNPS",
-        "KLAC", "CDNS", "MAR", "ABNB", "CTAS", "ORLY", "MRVL", "NXPI",
-        "CRWD", "FTNT", "CSX", "ADSK", "MNST", "DXCM", "WDAY", "AZN",
-        "PCAR", "ROP", "PAYX", "ROST", "CPRT", "FAST", "ODFL", "CTSH",
-        "EA", "VRSK", "CHTR", "CSGP", "GEHC", "BKR", "XEL", "TEAM",
-        "IDXX", "DASH", "ON", "LULU", "KDP", "ANSS", "ZS", "FANG",
-        "MCHP", "TTWO", "BIIB", "DDOG", "CDW", "ALGN", "ILMN", "WBD",
-        "MRNA", "GFS", "SMCI", "WBA", "ZM", "RIVN", "LCID", "PLUG"
-    ]
-
-    # Fallback list of popular NYSE tickers
-    NYSE_POPULAR = [
-        "BRK.B", "UNH", "JNJ", "XOM", "JPM", "V", "PG", "MA", "HD", "CVX",
-        "MRK", "ABBV", "KO", "LLY", "BAC", "PFE", "WMT", "TMO", "DIS", "ABT",
-        "CRM", "ACN", "VZ", "ORCL", "NKE", "MCD", "ADBE", "DHR", "PM", "NEE",
-        "CSCO", "WFC", "TXN", "BMY", "UPS", "RTX", "LOW", "MS", "SPGI", "HON",
-        "UNP", "QCOM", "T", "GS", "ELV", "INTU", "CAT", "IBM", "DE", "AMGN",
-        "BA", "BLK", "AXP", "PLD", "GILD", "SBUX", "ADI", "MDLZ", "GE", "ISRG",
-        "C", "BKNG", "TJX", "VRTX", "CB", "MMC", "SYK", "AMT", "REGN", "CI",
-        "LRCX", "ADP", "SO", "DUK", "ZTS", "MO", "PGR", "FI", "SCHW", "BSX",
-        "ITW", "EOG", "SLB", "MMM", "APD", "CL", "BDX", "TGT", "USB", "NOC",
-        "HUM", "AON", "EMR", "ICE", "PNC", "CME", "ETN", "SHW", "MCO", "FCX"
-    ]
+    def load_commodities_tickers(self) -> list[str]:
+        """Return curated commodity tickers only (no public API available)"""
+        logger.info("Using curated list of commodity tickers")
+        return self.COMMODITIES_POPULAR.copy()
 
-    def load_active_nasdaq_tickers(self) -> list[str]:
-        """Load NASDAQ tickers with fallback to popular list"""
+    def load_active_tse_tickers(self) -> list[str]:
+        """Load TSE tickers from API, fallback to curated list"""
+        try:
+            url = "https://www.jpx.co.jp/english/markets/statistics-equities/misc/tvdivq00000030km-att/data.csv"
+            resp = requests.get(url, timeout=10)
+            resp.raise_for_status()
+            df = pd.read_csv(StringIO(resp.text))
+            tickers = df["Code"].astype(str).tolist()
+            logger.info(f"Loaded {len(tickers)} TSE tickers from API")
+            return tickers
+        except Exception as e:
+            logger.warning(f"Failed to load TSE tickers from API: {e}")
+            return self.TSE_POPULAR.copy()
+
+    def load_active_hkex_tickers(self) -> list[str]:
+        """Load HKEX tickers from API, fallback to curated list"""
         try:
-            # Try alternative HTTP source (uses GitHub mirror)
-            logger.info("Attempting to fetch NASDAQ tickers from alternative source...")
-            url = "https://raw.githubusercontent.com/rreichel3/US-Stock-Symbols/main/nasdaq/nasdaq_tickers.txt"
-            response = requests.get(url, timeout=10)
-            if response.status_code == 200:
-                tickers = [line.strip() for line in response.text.strip().split('\n') if line.strip()]
-                logger.info(f"Successfully fetched {len(tickers)} NASDAQ tickers from alternative source")
-                return tickers
+            url = "https://www.hkex.com.hk/eng/services/trading/securities/securitieslists/ListOfSecurities.xlsx"
+            resp = requests.get(url, timeout=10)
+            resp.raise_for_status()
+            # For simplicity, fallback to curated list (parsing XLSX requires more code)
+            # TODO: Implement XLSX parsing if needed
+            logger.info("HKEX API loaded, but using curated list for now")
+            return self.HKEX_POPULAR.copy()
         except Exception as e:
-            logger.warning(f"Failed to fetch from alternative source: {e}")
+            logger.warning(f"Failed to load HKEX tickers from API: {e}")
+            return self.HKEX_POPULAR.copy()
 
-        # Fallback to popular tickers
-        logger.warning("Using fallback list of popular NASDAQ tickers")
-        return self.NASDAQ_POPULAR.copy()
+    def load_active_tsx_tickers(self) -> list[str]:
+        """Load TSX tickers from API, fallback to curated list"""
+        try:
+            url = "https://www.tsx.com/json/company-directory/search"
+            resp = requests.get(url, timeout=10)
+            resp.raise_for_status()
+            data = resp.json()
+            tickers = [item["symbol"] for item in data["results"]]
+            logger.info(f"Loaded {len(tickers)} TSX tickers from API")
+            return tickers
+        except Exception as e:
+            logger.warning(f"Failed to load TSX tickers from API: {e}")
+            return self.TSX_POPULAR.copy()
 
-    def load_active_nyse_tickers(self) -> list[str]:
-        """Load NYSE tickers with fallback to popular list"""
+    def load_active_euronext_tickers(self) -> list[str]:
+        """Load Euronext tickers from API, fallback to curated list"""
         try:
-            # Try alternative HTTP source
-            logger.info("Attempting to fetch NYSE tickers from alternative source...")
-            url = "https://raw.githubusercontent.com/rreichel3/US-Stock-Symbols/main/nyse/nyse_tickers.txt"
-            response = requests.get(url, timeout=10)
-            if response.status_code == 200:
-                tickers = [line.strip() for line in response.text.strip().split('\n') if line.strip()]
-                logger.info(f"Successfully fetched {len(tickers)} NYSE tickers from alternative source")
-                return tickers
+            url = "https://live.euronext.com/en/markets/equities/directory"
+            resp = requests.get(url, timeout=10)
+            resp.raise_for_status()
+            # For simplicity, fallback to curated list (parsing HTML requires more code)
+            # TODO: Implement HTML parsing if needed
+            logger.info("Euronext API loaded, but using curated list for now")
+            return self.EURONEXT_POPULAR.copy()
         except Exception as e:
-            logger.warning(f"Failed to fetch from alternative source: {e}")
+            logger.warning(f"Failed to load Euronext tickers from API: {e}")
+            return self.EURONEXT_POPULAR.copy()
 
-        # Fallback to popular tickers
-        logger.warning("Using fallback list of popular NYSE tickers")
-        return self.NYSE_POPULAR.copy()
+    def load_active_etf_tickers(self) -> list[str]:
+        """Return curated ETF tickers only (no public API available)"""
+        logger.info("Using curated list of ETF tickers")
+        return self.ETF_POPULAR.copy()
 
     def get_tickers(self, exchange: StockExchange) -> list[str]:
         logger.info(f"Fetching tickers for {exchange.value}")
         try:
-            if exchange == StockExchange.NASDAQ:
-                tickers = self.load_active_nasdaq_tickers()
-            elif exchange == StockExchange.NYSE:
-                tickers = self.load_active_nyse_tickers()
+            loaders = {
+                StockExchange.NASDAQ: self.load_active_nasdaq_tickers,
+                StockExchange.NYSE: self.load_active_nyse_tickers,
+                StockExchange.AMEX: self.load_active_amex_tickers,
+                StockExchange.LSE: self.load_active_lse_tickers,
+                StockExchange.TSE: self.load_active_tse_tickers,
+                StockExchange.HKEX: self.load_active_hkex_tickers,
+                StockExchange.TSX: self.load_active_tsx_tickers,
+                StockExchange.EURONEXT: self.load_active_euronext_tickers,
+                StockExchange.ETF: self.load_active_etf_tickers,
+            }
+
+            loader = loaders.get(exchange)
+            if loader:
+                tickers = loader()
             else:
                 logger.warning(f"Unknown exchange: {exchange.value}, using NASDAQ fallback")
                 tickers = self.NASDAQ_POPULAR.copy()
@@ -119,6 +186,5 @@ class TickersProvider:
             return tickers
         except Exception as e:
             logger.error(f"Error fetching tickers: {e}", exc_info=True)
-            # Final fallback
             logger.warning("Using NASDAQ popular tickers as final fallback")
             return self.NASDAQ_POPULAR.copy()

src/telegram_bot/telegram_bot_service.py

@@ -188,6 +188,18 @@ class TelegramBotService:
             response += "/insiders - Provides key insider's trades\n"
             response += "/insiders NVDA 30 - Insider's trades for the last 30 days\n"
             response += "/scan EXCHANGE - Scan for top 20 growing tickers (e.g., /scan NASDAQ)\n"
+            response += (
+                "\n<b>/scan Command Details:</b>\n"
+                "Usage: <code>/scan [EXCHANGE] [TIMEFRAME]</code>\n"
+                "Supported timeframes: <b>1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max</b>\n"
+                "Examples:\n"
+                "• /scan NASDAQ 1y\n"
+                "• /scan NYSE 6mo\n"
+                "• /scan LSE max\n"
+                "• /scan ETF 3mo\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"
@@ -663,23 +675,75 @@ class TelegramBotService:
     async def handle_scan_command(
             self, chat_id: int, command_parts: list[str], text: str | None, user_name: str
     ) -> None:
-        """Ticker scanner command handler"""
-        # Default to NASDAQ
+        """
+        Ticker scanner command handler
+
+        Usage: /scan [EXCHANGE] [TIMEFRAME]
+        Examples:
+            /scan               -> NASDAQ, max
+            /scan NYSE          -> NYSE, max
+            /scan NASDAQ 6mo    -> NASDAQ, 6mo
+            /scan NYSE 2y       -> NYSE, 2y
+        """
+        # Default values
         exchange = "NASDAQ"
+        timeframe = "max"
+
+        # Parse exchange
         if len(command_parts) >= 2:
             exchange = command_parts[1].upper()
+
+        # Parse timeframe
+        if len(command_parts) >= 3:
+            timeframe = command_parts[2].lower()
+
         # Validate exchange
-        valid_exchanges = ["NASDAQ", "NYSE"]
+        valid_exchanges = [
+            # American
+            "NASDAQ", "NYSE", "AMEX",
+            # European
+            "LSE", "EURONEXT", "FWB", "SIX",
+            # Asian
+            "TSE", "HKEX", "SSE",
+            # Others
+            "TSX", "ASX",
+            # Special
+            "ETF"
+        ]
         if exchange not in valid_exchanges:
             await self.send_message_via_proxy(
                 chat_id,
                 f"❌ Invalid exchange: {exchange}\n\n"
-                f"Supported exchanges: {', '.join(valid_exchanges)}\n\n"
-                f"Examples:\n• /scan NASDAQ\n• /scan NYSE"
+                f"🇺🇸 <b>American:</b> NASDAQ, NYSE, AMEX\n"
+                f"🇪🇺 <b>European:</b> LSE, EURONEXT, FWB, SIX\n"
+                f"🇦🇸 <b>Asian:</b> TSE, HKEX, SSE\n"
+                f"🌎 <b>Others:</b> TSX, ASX\n"
+                f"📊 <b>Special:</b> ETF\n\n"
+                f"<b>Examples:</b>\n"
+                f"• /scan NASDAQ\n"
+                f"• /scan TSE 1y\n"
+                f"• /scan ETF 6mo"
             )
             return
+
+        # Validate timeframe
+        valid_timeframes = ["1d", "5d", "1mo", "3mo", "6mo", "1y", "2y", "5y", "10y", "ytd", "max"]
+        if timeframe not in valid_timeframes:
+            await self.send_message_via_proxy(
+                chat_id,
+                f"❌ Invalid timeframe: {timeframe}\n\n"
+                f"Supported timeframes:\n"
+                f"• Short: 1d, 5d, 1mo, 3mo\n"
+                f"• Medium: 6mo, 1y, 2y\n"
+                f"• Long: 5y, 10y, ytd, max\n\n"
+                f"Examples:\n"
+                f"• /scan NASDAQ 1y\n"
+                f"• /scan NYSE 6mo"
+            )
+            return
+
         # Send loading message
-        loading_msg = f"🔍 <b>Scanning {exchange} for top growing tickers...</b>\n\n"
+        loading_msg = f"🔍 <b>Scanning {exchange} ({timeframe}) for top growing tickers...</b>\n\n"
         loading_msg += "⏳ This may take a few minutes:\n"
         loading_msg += "📥 Downloading historical data...\n"
         loading_msg += "📊 Analyzing growth metrics...\n"
@@ -690,14 +754,15 @@ class TelegramBotService:
             analyzer = TickerAnalyzer(
                 exchange=exchange,
                 telegram_bot_service=self,
-                limit=1000  # Limit to 1000 tickers for reasonable execution time
+                limit=1000,  # Limit to 1000 tickers for reasonable execution time
+                timeframe=timeframe
             )
-            logger.info(f"Starting ticker scan for {exchange}")
+            logger.info(f"Starting ticker scan for {exchange} with timeframe {timeframe}")
             top_tickers = await analyzer.run_analysis()
             # Format and send results
             message = analyzer._format_telegram_message(top_tickers)
             await self.send_message_via_proxy(chat_id, message)
-            logger.info(f"Ticker scan completed for {exchange}")
+            logger.info(f"Ticker scan completed for {exchange} ({timeframe})")
         except Exception as e:
             logger.error(f"Error in ticker scanner: {e}", exc_info=True)
             error_msg = f"❌ An error occurred during ticker scanning:\n\n{str(e)}\n\n"