tradingview-mcp 26.3.0__tar.gz → 26.3.2__tar.gz

{tradingview_mcp-26.3.0 → tradingview_mcp-26.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingview-mcp
-Version: 26.3.0
+Version: 26.3.2
 Summary: A comprehensive MCP server for TradingView market screening with integrated screener functionality
 Project-URL: Homepage, https://github.com/k73a/tradingview-mcp
 Project-URL: Documentation, https://github.com/k73a/tradingview-mcp#readme

{tradingview_mcp-26.3.0 → tradingview_mcp-26.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tradingview-mcp"
-version = "26.3.0"
+version = "26.3.2"
 description = "A comprehensive MCP server for TradingView market screening with integrated screener functionality"
 readme = "README.md"
 license = { text = "MIT" }

{tradingview_mcp-26.3.0 → tradingview_mcp-26.3.2}/src/tradingview_mcp/tools/reference.py

@@ -49,8 +49,21 @@ def get_filter_example(type: str = "number") -> dict[str, Any]:
     """Get example filter format."""
     return get_filter_format(type)
 
+from tradingview_mcp.utils import sanitize_market
+
 def check_market(market: str) -> dict[str, Any]:
     """Validate a market name."""
+    # Resolve alias first (e.g. 'tw' -> 'taiwan') for consistency with other tools
+    # We use strict=False because we want the default 'america' if fails? No, check_market should be explicit.
+    # sanitize_market returns default 'america' if invalid.
+    # We want to know if it's strictly valid or valid alias.
+    
+    # Check if it's a known alias
+    clean = market.strip().lower()
+    from tradingview_mcp.utils import COUNTRY_ALIASES
+    if clean in COUNTRY_ALIASES:
+        return validate_market(COUNTRY_ALIASES[clean])
+        
     return validate_market(market)
 
 def get_help() -> dict[str, Any]:

{tradingview_mcp-26.3.0 → tradingview_mcp-26.3.2}/src/tradingview_mcp/tools/screener.py

@@ -15,7 +15,7 @@ def screen_market(
     filters: Optional[list[dict[str, Any]]] = None,
 ) -> dict[str, Any]:
     """Run a custom market screening query."""
-    market = sanitize_market(market)
+    market = sanitize_market(market, strict=True)
     limit = max(1, min(limit, 500))
     
     # Ensure description is always included
@@ -71,17 +71,17 @@ def screen_market(
 
 def get_top_gainers(market: str = "america", limit: int = 25) -> dict[str, Any]:
     """Get top gainers for a market."""
-    market = sanitize_market(market)
+    market = sanitize_market(market, strict=True)
     return screen_market(market, sort_by="change", ascending=False, limit=limit)
 
 
 def get_top_losers(market: str = "america", limit: int = 25) -> dict[str, Any]:
     """Get top losers for a market."""
-    market = sanitize_market(market)
+    market = sanitize_market(market, strict=True)
     return screen_market(market, sort_by="change", ascending=True, limit=limit)
 
 
 def get_most_active(market: str = "america", limit: int = 25) -> dict[str, Any]:
     """Get most active symbols by volume."""
-    market = sanitize_market(market)
+    market = sanitize_market(market, strict=True)
     return screen_market(market, sort_by="volume", ascending=False, limit=limit)

tradingview_mcp-26.3.2/src/tradingview_mcp/tools/search.py

@@ -0,0 +1,417 @@
+from __future__ import annotations
+from typing import Any
+import concurrent.futures
+
+from mcp.server.fastmcp import Context
+
+from tradingview_mcp.column import Column
+from tradingview_mcp.constants import EXCHANGE_SCREENER
+from tradingview_mcp.docs_data import get_default_columns_for_market, STOCK_MARKETS
+from tradingview_mcp.query import Query
+from tradingview_mcp.utils import sanitize_market
+
+# Common aliases for commodities/forex that don't match TV names
+SYMBOL_ALIASES = {
+    # Precious Metals
+    "XAG": ["SILVER", "XAGUSD"],
+    "XAU": ["GOLD", "XAUUSD"],
+    "XPT": ["PLATINUM", "XPTUSD"],
+    "XPD": ["PALLADIUM", "XPDUSD"],
+    
+    # Energy
+    "OIL": ["USOIL", "UKOIL", "WTI", "BRENT"],
+    "WTI": ["USOIL"],
+    "BRENT": ["UKOIL"],
+    "NATGAS": ["NG1!", "NATURALGAS"],
+    
+    # Others
+    "COPPER": ["HG1!", "XCUUSD"],
+}
+
+def search_symbols(
+    query: str,
+    market: str = "america",
+    limit: int = 25,
+) -> dict[str, Any]:
+    """
+    Search symbols by name or ticker. Returns strict locator format for downstream tools.
+    
+    Output format includes 'locator': 'EXCHANGE:SYMBOL, market_name'.
+    Use this locator to call get_technical_analysis() or other tools precisely.
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+    
+    # Use dynamic default columns for this market
+    cols = get_default_columns_for_market(market)
+    
+    # Determine sort column
+    sort_col = "market_cap_basic" if "market_cap_basic" in cols else "name"
+    
+    # Expand query with aliases if available
+    queries = [query]
+    if query.upper() in SYMBOL_ALIASES:
+        queries.extend(SYMBOL_ALIASES[query.upper()])
+
+    try:
+        # Standard search in requested market
+        # We start this async to allow parallel peeking
+        with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
+            future_main = executor.submit(_execute_search, queries, market, limit, cols, sort_col)
+            
+            # Smart Peek: Always check CFD/Forex/Crypto for EXACT matches or high relevance
+            # This solves the "Silver" problem: "Silver" exists in America (Stocks), but user might want "SILVER" (CFD)
+            # We don't want to wait for main search to fail (lazy fallback), we want to augment results.
+            peek_markets = ["cfd", "crypto", "forex"]
+            if market in peek_markets:
+                 peek_markets.remove(market)
+            
+            future_peeks = []
+            for pm in peek_markets:
+                # For peeking, we only care about high relevance, so limit is small
+                p_cols = get_default_columns_for_market(pm)
+                p_sort = "name" # Sort by name match
+                future_peeks.append(executor.submit(_execute_search, queries, pm, 5, p_cols, p_sort))
+            
+            # Gather Main Results
+            results = future_main.result()
+            
+            # Gather Peek Results
+            extra_matches = []
+            for f in future_peeks:
+                try:
+                    res = f.result()
+                    if res.get("results"):
+                        extra_matches.extend(res["results"])
+                except:
+                    pass
+        
+        # Merge Logic
+        # 1. Start with Main Results
+        final_list = results.get("results", [])
+        
+        # 2. Inject Exact Matches from Peeks at the TOP
+        #    (e.g. if query="Silver" and we found "SILVER" in CFD, put it first)
+        high_priority = []
+        low_priority = []
+        
+        query_upper = query.upper()
+        
+        for m in extra_matches:
+            # Check for exact ticker/name match
+            n = m.get("name", "").upper()
+            tick = m.get("ticker", "").split(":")[-1].upper()
+            
+            if n == query_upper or tick == query_upper or f"{query_upper}USD" in n:
+                high_priority.append(m)
+            else:
+                low_priority.append(m)
+        
+        # specific uniqueness check
+        seen = {f"{r.get('exchange')}:{r.get('name')}" for r in final_list}
+        
+        merged = []
+        # Add High Priority Peeks (if new)
+        for r in high_priority:
+            k = f"{r.get('exchange')}:{r.get('name')}"
+            if k not in seen:
+                merged.append(r)
+                seen.add(k)
+                
+        # Add Main Results
+        merged.extend(final_list)
+        
+        # Add Low Priority Peeks (only if we have space or main list is empty)
+        # Actually, let's append them if main list is small, or specialized matching
+        if not final_list:
+             for r in low_priority:
+                k = f"{r.get('exchange')}:{r.get('name')}"
+                if k not in seen:
+                    merged.append(r)
+                    seen.add(k)
+                    
+        # Update results
+        results["results"] = merged
+        results["total_found"] = len(merged)
+        results["returned"] = len(merged)
+        
+        # Fallback Logic (Only if truly empty)
+        if not results["results"] and market == "america":
+            
+            # 1. Asian Numeric Heuristic
+            if query.isdigit() and len(query) in [4, 5, 6]:
+                # ... existing heuristic code ...
+                asian_markets = ["taiwan", "hongkong", "japan", "china", "korea"]
+                for asian_market in asian_markets:
+                    asian_cols = get_default_columns_for_market(asian_market)
+                    asian_sort = "volume"
+                    asian_res = _execute_search(queries, asian_market, 5, asian_cols, asian_sort)
+                    if asian_res["results"]:
+                         return {**asian_res, "note": f"No results in 'america', using numeric heuristic for '{asian_market}'."}
+
+            # 2. True Global Search
+            try:
+                global_cols = ["name", "description", "close", "change", "volume", "market_cap_basic", "exchange", "type"]
+                q = (
+                    Query()
+                    .set_markets(*STOCK_MARKETS)
+                    .select(*global_cols)
+                    .where(Column("description").like(query))
+                    .order_by("volume", ascending=False)
+                    .limit(5)
+                )
+                _, df = q.get_scanner_data()
+                
+                if df.empty:
+                     q = (
+                        Query()
+                        .set_markets(*STOCK_MARKETS)
+                        .select(*global_cols)
+                        .where(Column("name").like(query))
+                        .order_by("volume", ascending=False)
+                        .limit(5)
+                     )
+                     _, df = q.get_scanner_data()
+                
+                if not df.empty:
+                     # Add locators for global results
+                     records = df.to_dict("records")
+                     for r in records:
+                          _enrich_locator(r, "stock", query) 
+                     
+                     return {
+                        "query": query,
+                        "market": "global",
+                        "total_found": len(df),
+                        "returned": len(df),
+                        "results": records,
+                        "note": "Found matches in global stock markets."
+                    }
+            except Exception:
+                pass
+
+        return results
+        
+    except Exception as e:
+        return _search_symbols_fallback(query, market, limit, cols, str(e))
+
+
+def _enrich_locator(record: dict, market: str, category: str = "stock"):
+    """Add standard locator string to a record."""
+    ex = record.get("exchange", "UNKNOWN")
+    name = record.get("name", "UNKNOWN")
+    
+    # Try to deduce market if 'stock' is generic
+    # (This is hard without a map of Exchange->Country, but we do our best)
+    
+    # Construct Locator
+    # Format: EXCHANGE:SYMBOL, Market
+    record["locator"] = f"{ex}:{name}, {market}"
+    record["market"] = market
+
+
+def _execute_search(queries: list[str] | str, market: str, limit: int, cols: list[str], sort_col: str) -> dict[str, Any]:
+    """Execute search, supporting multiple query terms (aliases)."""
+    if isinstance(queries, str):
+        queries = [queries]
+        
+    all_results = []
+    
+    # Try each query term until we get enough results
+    for q_term in queries:
+        if len(all_results) >= limit: break
+        
+        try:
+            # 1. Search description
+            q = (
+                Query()
+                .set_markets(market)
+                .select(*cols)
+                .where(Column("description").like(q_term))
+                .order_by(sort_col, ascending=False)
+                .limit(limit)
+            )
+            _, df = q.get_scanner_data()
+            if not df.empty:
+                 all_results.extend(df.to_dict("records"))
+            
+            # 2. Search name
+            if len(all_results) < limit:
+                q2 = (
+                    Query()
+                    .set_markets(market)
+                    .select(*cols)
+                    .where(Column("name").like(q_term))
+                    .order_by(sort_col, ascending=False)
+                    .limit(limit)
+                )
+                _, df2 = q2.get_scanner_data()
+                if not df2.empty:
+                     all_results.extend(df2.to_dict("records"))
+        except:
+            pass
+            
+    # Dedup
+    unique = {r.get("name")+r.get("exchange"): r for r in all_results}
+    results = list(unique.values())[:limit]
+    
+    # Enhance with locator
+    for r in results:
+        _enrich_locator(r, market)
+    
+    return {
+        "query": queries[0], 
+        "market": market,
+        "total_found": len(results),
+        "returned": len(results),
+        "results": results,
+    }
+
+
+def _search_symbols_fallback(query: str, market: str, limit: int, cols: list[str], error: str) -> dict[str, Any]:
+    return {"error": f"Search failed: {str(e)}", "original_error": error}
+
+
+def get_symbol_info(symbol: str, include_technical: bool = False) -> dict[str, Any]:
+    """
+    Get detailed information for a symbol.
+    Returns matches with strict locators: 'EXCHANGE:SYMBOL, Market'.
+    """
+    technical_cols = [
+        "RSI", "RSI7", "MACD.macd", "MACD.signal", "SMA20", "SMA50", "SMA200", 
+        "EMA20", "EMA50", "EMA200", "BB.upper", "BB.lower", "ATR", "ADX", 
+        "Recommend.All", "Recommend.MA", "Recommend.Other"
+    ]
+
+    try:
+        # --- Strict Mode (Exchange Specified) ---
+        if ":" in symbol:
+            exchange, ticker = symbol.split(":", 1)
+            market = EXCHANGE_SCREENER.get(exchange.lower()) or "america"
+            
+            # Allow override via sanitized lookup? No, specific exchange implies specific market logic usually.
+            # But let's be safe.
+            
+            cols = get_default_columns_for_market(market)
+            if include_technical: cols.extend(technical_cols)
+            cols = list(dict.fromkeys(cols))
+
+            q = (
+                Query()
+                .set_markets(market)
+                .select(*cols)
+                .where(Column("name").isin([symbol, ticker, symbol.upper(), ticker.upper()]))
+                .limit(5)
+            )
+            _, df = q.get_scanner_data()
+            results = df.to_dict("records")
+            
+            if results:
+                # Add strict locators
+                for r in results:
+                    _enrich_locator(r, market)
+                    
+                if len(results) == 1:
+                    return {"symbol": symbol, "found": True, "market": market, "data": results[0]}
+                return {"symbol": symbol, "found": True, "market": market, "matches": results}
+            else:
+                return {"symbol": symbol, "found": False, "hint": f"Symbol not found in {market} ({exchange}). Check format."}
+
+        # --- Universal Mode (Implicit Market) ---
+        all_matches = []
+        
+        # Targets
+        targets = [symbol, symbol.upper(), f"{symbol}USDT", f"{symbol}USD"]
+        if symbol.upper() in SYMBOL_ALIASES:
+            targets.extend(SYMBOL_ALIASES[symbol.upper()])
+        
+        # Helper
+        def run_search(market, col_getter):
+             try:
+                cols = col_getter(market)
+                if include_technical: cols.extend(technical_cols)
+                cols = list(dict.fromkeys(cols))
+                
+                # We need to set markets properly
+                q = Query()
+                if market == "global_stocks":
+                    q.set_markets(*STOCK_MARKETS)
+                else:
+                    q.set_markets(market)
+                
+                q.select(*cols).where(Column("name").isin(targets))
+                
+                if market == "global_stocks":
+                    q.order_by("market_cap_basic", ascending=False).limit(10)
+                else:
+                    q.limit(5)
+                    
+                _, df = q.get_scanner_data()
+                if not df.empty:
+                    matches = df.to_dict("records")
+                    cat = "stock" if market == "global_stocks" else market
+                    
+                    # Fixup locator logic 
+                    for m in matches: 
+                        m["_category"] = cat
+                        # If global stock, we don't know exact country easily without map.
+                        # But for now we pass 'global_stocks' or try to guess?
+                        # It's better to tell AI "taiwan" if possible.
+                        # But we queried ALL markets. 
+                        # HACK: We should query 'taiwan' explicitly if heuristics match?
+                        # No, just return EXCHANGE:SYMBOL and let AI use 'search_symbols' if it needs precise market.
+                        # Actually user wants "TWSE:0050, taiwan".
+                        # If we used set_markets(*ALL), we lose the origin market info in the response unless we select 'market' column?
+                        # TradingView API doesn't usually return 'market' column. It returns 'exchange'.
+                        # We can map Exchange -> Market via EXCHANGE_SCREENER?
+                        rec_market = EXCHANGE_SCREENER.get(m.get("exchange", "").lower(), cat)
+                        _enrich_locator(m, rec_market)
+                        
+                    return matches
+             except:
+                 pass
+             return []
+
+        # Execute in parallel
+        with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
+            futures = [
+                executor.submit(run_search, "global_stocks", lambda m: ["name", "description", "close", "change", "volume", "market_cap_basic", "exchange", "type"]),
+                executor.submit(run_search, "crypto", get_default_columns_for_market),
+                executor.submit(run_search, "forex", get_default_columns_for_market),
+                executor.submit(run_search, "cfd", get_default_columns_for_market)
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                all_matches.extend(future.result())
+
+        # --- Aggregate Results ---
+        if not all_matches:
+             return search_symbols(symbol, "america", 5)
+
+        # Remove duplicates
+        unique_matches = {}
+        for m in all_matches:
+            key = m.get("ticker", m.get("name"))
+            if key not in unique_matches:
+                unique_matches[key] = m
+        
+        final_matches = list(unique_matches.values())
+
+        if len(final_matches) == 1:
+            first = final_matches[0]
+            cat = first.pop("_category", "global")
+            return {"symbol": symbol, "found": True, "market": cat, "data": first}
+        
+        return {
+            "symbol": symbol,
+            "found": True, 
+            "market": "global", 
+            "count": len(final_matches),
+            "matches": final_matches,
+            "note": "Multiple matches found across global markets."
+        }
+
+    except Exception as e:
+        return {
+            "error": f"Failed to get symbol info: {str(e)}",
+            "hint": "Try using search_symbols to find the correct symbol format",
+        }

{tradingview_mcp-26.3.0 → tradingview_mcp-26.3.2}/src/tradingview_mcp/tools/technical.py

@@ -6,9 +6,26 @@ from tradingview_mcp.constants import TECHNICAL_COLUMNS
 from tradingview_mcp.query import Query
 from tradingview_mcp.utils import sanitize_market
 
-def get_technical_analysis(symbol: str, market: str = "america") -> dict[str, Any]:
-    """Get technical indicators for a symbol."""
-    market = sanitize_market(market)
+def get_technical_analysis(symbol: str, market: str) -> dict[str, Any]:
+    """
+    Get technical indicators for a symbol.
+    
+    IMPORTANT: You must use a strictly formatted symbol and market.
+    1. Call `get_symbol_info(symbol)` first.
+    2. Use the `locator` field from the response (e.g. "EXCHANGE:SYMBOL") and the exact `market`.
+    3. Do NOT guess the market.
+    """
+    # Strict validation
+    if ":" not in symbol:
+        return {
+            "error": "Ambiguous symbol format. Missing exchange prefix.",
+            "hint": f"Please run get_symbol_info('{symbol}') first to find the correct 'EXCHANGE:{symbol}' locator and 'market'."
+        }
+    
+    # Parse strictly formatted symbol
+    exchange, ticker = symbol.split(":", 1)
+    
+    market = sanitize_market(market, strict=True)
     
     # Use standard technical columns
     cols = list(TECHNICAL_COLUMNS)
@@ -18,13 +35,19 @@ def get_technical_analysis(symbol: str, market: str = "america") -> dict[str, An
             Query()
             .set_markets(market)
             .select(*cols)
-            .where(Column("name").isin([symbol, symbol.upper()]))
+            .where(Column("name").isin([ticker, ticker.upper()])) # Use ticker part for name lookup
             .limit(1)
         )
+
         _, df = q.get_scanner_data()
         
         if df.empty:
-            return {"error": f"Symbol {symbol} not found in {market}"}
+            # Check if user maybe used wrong market?
+            # But we want to be strict.
+            return {
+                "error": f"Symbol '{symbol}' not found in market '{market}'.",
+                "hint": "Ensure you are using the correct market from get_symbol_info()."
+            }
             
         data = df.iloc[0].to_dict()
         return {
@@ -37,7 +60,7 @@ def get_technical_analysis(symbol: str, market: str = "america") -> dict[str, An
 
 def scan_rsi_extremes(market: str = "america", limit: int = 25) -> dict[str, Any]:
     """Find symbols with extreme RSI values (<30 or >70)."""
-    market = sanitize_market(market)
+    market = sanitize_market(market, strict=True)
     
     q = (
         Query()
@@ -77,7 +100,7 @@ def scan_rsi_extremes(market: str = "america", limit: int = 25) -> dict[str, Any
 
 def scan_bollinger_bands(market: str = "america", limit: int = 25) -> dict[str, Any]:
     """Find symbols trading outside Bollinger Bands."""
-    market = sanitize_market(market)
+    market = sanitize_market(market, strict=True)
     # This is complex to do with simple filters.
     # We'll just return basic BB values for top volume stocks.
     
@@ -97,7 +120,7 @@ def scan_bollinger_bands(market: str = "america", limit: int = 25) -> dict[str,
 
 def scan_macd_crossover(market: str = "america", limit: int = 25) -> dict[str, Any]:
     """scan for MACD crossovers."""
-    market = sanitize_market(market)
+    market = sanitize_market(market, strict=True)
     q = (
         Query()
         .set_markets(market)

{tradingview_mcp-26.3.0 → tradingview_mcp-26.3.2}/src/tradingview_mcp/utils.py

@@ -54,21 +54,89 @@ def sanitize_exchange(ex: str | None, default: str = "america") -> str:
     return default
 
 
-def sanitize_market(market: str | None, default: str = "america") -> str:
+# Country Code mappings
+COUNTRY_ALIASES = {
+    "us": "america",
+    "usa": "america",
+    "uk": "uk",
+    "gb": "uk",
+    "de": "germany",
+    "fr": "france",
+    "it": "italy",
+    "es": "spain",
+    "pt": "portugal",
+    "ch": "switzerland",
+    "se": "sweden",
+    "no": "norway",
+    "fi": "finland",
+    "nl": "netherlands",
+    "be": "belgium",
+    "at": "austria",
+    "ie": "ireland",
+    "ru": "russia",
+    "cn": "china",
+    "jp": "japan",
+    "kr": "korea",
+    "in": "india",
+    "id": "indonesia",
+    "my": "malaysia",
+    "th": "thailand",
+    "vn": "vietnam",
+    "tw": "taiwan",
+    "sg": "singapore",
+    "hk": "hongkong",
+    "au": "australia",
+    "nz": "newzealand",
+    "ca": "canada",
+    "br": "brazil",
+    "mx": "mexico",
+    "ar": "argentina",
+    "cl": "chile",
+    "co": "colombia",
+    "pe": "peru",
+    "eg": "egypt",
+    "tr": "turkey",
+    "za": "rsa", # South Africa
+}
+
+def sanitize_market(market: str | None, default: str = "america", strict: bool = False) -> str:
     """
     Validate and sanitize a market name.
-
+    
     Args:
-        market: Market to validate
-        default: Default value if invalid
+        market: Market to validate (e.g. 'america', 'tw', 'crypto')
+        default: Default value if invalid (only used if strict=False)
+        strict: If True, raise ValueError for invalid markets instead of returning default.
 
     Returns:
         Valid market string
+        
+    Raises:
+        ValueError: If strict=True and market is invalid.
     """
     if not market:
+        if strict:
+            raise ValueError("Market parameter is required (e.g. 'america', 'taiwan').")
         return default
-    market = market.strip().lower()
-    return market if market in MARKETS else default
+    
+    market_clean = market.strip().lower()
+    
+    # Check exact match
+    if market_clean in MARKETS:
+        return market_clean
+        
+    # Check alias match
+    if market_clean in COUNTRY_ALIASES:
+        return COUNTRY_ALIASES[market_clean]
+        
+    # Check if user passed exchange (e.g. 'nasdaq') by mistake
+    if market_clean in EXCHANGE_SCREENER:
+        return EXCHANGE_SCREENER[market_clean]
+
+    if strict:
+        raise ValueError(f"Invalid market '{market}'. Please use a valid country code or name (e.g. 'america', 'taiwan', 'crypto').")
+
+    return default
 
 
 def timeframe_to_resolution(tf: str) -> str:

tradingview_mcp-26.3.0/src/tradingview_mcp/tools/search.py

@@ -1,326 +0,0 @@
-from __future__ import annotations
-from typing import Any
-import concurrent.futures
-
-from mcp.server.fastmcp import Context
-
-from tradingview_mcp.column import Column
-from tradingview_mcp.constants import EXCHANGE_SCREENER
-from tradingview_mcp.docs_data import get_default_columns_for_market, STOCK_MARKETS
-from tradingview_mcp.query import Query
-from tradingview_mcp.utils import sanitize_market
-
-def search_symbols(
-    query: str,
-    market: str = "america",
-    limit: int = 25,
-) -> dict[str, Any]:
-    """
-    Search symbols by name or ticker.
-    If default market returns no results, automatically searches crypto and forex.
-    """
-    market = sanitize_market(market)
-    limit = max(1, min(limit, 100))
-    
-    # Use dynamic default columns for this market
-    cols = get_default_columns_for_market(market)
-    
-    # Determine sort column
-    sort_col = "market_cap_basic" if "market_cap_basic" in cols else "name"
-    
-    try:
-        # Standard search in requested market
-        results = _execute_search(query, market, limit, cols, sort_col)
-        
-        # Smart Fallback: If default market ('america') yielded no results, try others
-        if not results["results"] and market == "america":
-            
-            # 1. Asian Numeric Heuristic (Prioritized for speed/accuracy)
-            if query.isdigit() and len(query) in [4, 5, 6]:
-                asian_markets = ["taiwan", "hongkong", "japan", "china", "korea"]
-                for asian_market in asian_markets:
-                    asian_cols = get_default_columns_for_market(asian_market)
-                    asian_sort = "volume" # Volume is good for general Asian scanners
-                    asian_res = _execute_search(query, asian_market, 5, asian_cols, asian_sort)
-                    if asian_res["results"]:
-                         return {**asian_res, "note": f"No results in 'america', found matches in '{asian_market}' (numeric heuristic)"}
-
-            # 2. True Global Search (Check ALL 68+ Stock Markets)
-            try:
-                # Use standard global columns safe for all
-                global_cols = ["name", "description", "close", "change", "volume", "market_cap_basic", "exchange", "type"]
-                
-                # Check Description First (often better for "Maybank")
-                q = (
-                    Query()
-                    .set_markets(*STOCK_MARKETS)
-                    .select(*global_cols)
-                    .where(Column("description").like(query))
-                    .order_by("volume", ascending=False)
-                    .limit(5)
-                )
-                _, df = q.get_scanner_data()
-                
-                if df.empty:
-                     # Check Name (Ticker)
-                     q = (
-                        Query()
-                        .set_markets(*STOCK_MARKETS)
-                        .select(*global_cols)
-                        .where(Column("name").like(query))
-                        .order_by("volume", ascending=False)
-                        .limit(5)
-                     )
-                     _, df = q.get_scanner_data()
-                
-                if not df.empty:
-                     # Basic Global Result
-                     total = len(df) # Roughly
-                     return {
-                        "query": query,
-                        "market": "global",
-                        "total_found": total,
-                        "returned": len(df),
-                        "results": df.to_dict("records"),
-                        "note": "No results in 'america', found matches in global stock markets."
-                    }
-                    
-            except Exception:
-                pass # Continue to other fallbacks
-
-            # 3. Check Crypto/Forex
-            for other in ["crypto", "forex"]:
-                 if other == market: continue
-                 
-                 cols = get_default_columns_for_market(other)
-                 sort = "market_cap_basic" if "market_cap_basic" in cols else "name"
-                 if other == "forex": sort = "name"
-                 
-                 res = _execute_search(query, other, 5, cols, sort)
-                 if res["results"]:
-                     return {**res, "note": f"No results in stocks, found matches in '{other}'"}
-
-        return results
-        
-    except Exception as e:
-        return _search_symbols_fallback(query, market, limit, cols, str(e))
-
-
-def _execute_search(query: str, market: str, limit: int, cols: list[str], sort_col: str) -> dict[str, Any]:
-    """Execute a single search query against a market."""
-    try:
-        # 1. Search description (company name)
-        query_obj = (
-            Query()
-            .set_markets(market)
-            .select(*cols)
-            .where(Column("description").like(query))
-            .order_by(sort_col, ascending=False)
-            .limit(limit)
-        )
-        total, df = query_obj.get_scanner_data()
-        results = df.to_dict("records")
-        
-        # 2. If nothing found, search name (ticker)
-        if not results:
-            query_obj2 = (
-                Query()
-                .set_markets(market)
-                .select(*cols)
-                .where(Column("name").like(query))
-                .order_by(sort_col, ascending=False)
-                .limit(limit)
-            )
-            total, df = query_obj2.get_scanner_data()
-            results = df.to_dict("records")
-            
-        return {
-            "query": query,
-            "market": market,
-            "total_found": total if results else 0,
-            "returned": len(results),
-            "results": results,
-            "hint": "Use 'name' field as symbol for other tools" if results else "No matches found.",
-        }
-    except Exception:
-        return {"results": [], "market": market}
-
-
-def _search_symbols_fallback(query: str, market: str, limit: int, cols: list[str], error: str) -> dict[str, Any]:
-    """Fallback search when API operations fail."""
-    try:
-        q = Query().set_markets(market).select(*cols).limit(100)
-        _, df = q.get_scanner_data()
-        q_lower = query.lower()
-        mask = df["name"].str.lower().str.contains(q_lower) | df["description"].str.lower().str.contains(q_lower)
-        df_filtered = df[mask].head(limit)
-        return {
-            "query": query,
-            "market": market,
-            "returned": len(df_filtered),
-            "results": df_filtered.to_dict("records"),
-            "note": "Used fallback local search.",
-            "original_error": error,
-        }
-    except Exception as e:
-        return {"error": f"Search failed: {str(e)}", "original_error": error}
-
-
-def get_symbol_info(symbol: str, include_technical: bool = False) -> dict[str, Any]:
-    """
-    Get detailed information for a symbol.
-    
-    Modes:
-    1. Strict: 'EXCHANGE:SYMBOL' (e.g. 'NASDAQ:AAPL') - searches only that exchange/market.
-    2. Universal: 'SYMBOL' (e.g. 'AAA') - searches ALL global markets, Crypto, and Forex.
-       Returns ALL matches found to verify ambiguity.
-    """
-    technical_cols = [
-        "RSI", "RSI7", "MACD.macd", "MACD.signal", "SMA20", "SMA50", "SMA200", 
-        "EMA20", "EMA50", "EMA200", "BB.upper", "BB.lower", "ATR", "ADX", 
-        "Recommend.All", "Recommend.MA", "Recommend.Other"
-    ]
-
-    try:
-        # --- Strict Mode (Exchange Specified) ---
-        if ":" in symbol:
-            exchange, ticker = symbol.split(":", 1)
-            market = EXCHANGE_SCREENER.get(exchange.lower()) or "america"
-            
-            # Setup Columns
-            cols = get_default_columns_for_market(market)
-            if include_technical: cols.extend(technical_cols)
-            cols = list(dict.fromkeys(cols))
-
-            # Query
-            q = (
-                Query()
-                .set_markets(market)
-                .select(*cols)
-                .where(Column("name").isin([symbol, ticker, symbol.upper(), ticker.upper()]))
-                .limit(5)
-            )
-            _, df = q.get_scanner_data()
-            results = df.to_dict("records")
-            
-            if results:
-                if len(results) == 1:
-                    return {"symbol": symbol, "found": True, "market": market, "data": results[0]}
-                return {"symbol": symbol, "found": True, "market": market, "matches": results}
-            else:
-                return {"symbol": symbol, "found": False, "hint": f"Symbol not found in {market} ({exchange}). Check format."}
-
-        # --- Universal Mode (Implicit Market) ---
-        # We search Stocks (Global), Crypto, vs Forex in parallel using ThreadPoolExecutor
-        all_matches = []
-        
-        def check_global_stocks():
-            try:
-                stock_cols = ["name", "description", "close", "change", "volume", "market_cap_basic", "exchange", "type"]
-                if include_technical: stock_cols.extend(technical_cols)
-                stock_cols = list(dict.fromkeys(stock_cols))
-                
-                q_stocks = (
-                    Query()
-                    .set_markets(*STOCK_MARKETS)
-                    .select(*stock_cols)
-                    .where(Column("name").isin([symbol, symbol.upper()]))
-                    .order_by("market_cap_basic", ascending=False) 
-                    .limit(10)
-                )
-                _, df_stocks = q_stocks.get_scanner_data()
-                if not df_stocks.empty:
-                    matches = df_stocks.to_dict("records")
-                    for m in matches: m["_category"] = "stock"
-                    return matches
-            except Exception:
-                pass
-            return []
-
-        def check_crypto():
-            try:
-                crypto_cols = get_default_columns_for_market("crypto")
-                if include_technical: crypto_cols.extend(technical_cols)
-                crypto_cols = list(dict.fromkeys(crypto_cols))
-
-                q_crypto = (
-                    Query()
-                    .set_markets("crypto")
-                    .select(*crypto_cols)
-                    .where(Column("name").isin([symbol, symbol.upper(), f"{symbol}USDT", f"{symbol}USD"]))
-                    .limit(5)
-                )
-                _, df_crypto = q_crypto.get_scanner_data()
-                if not df_crypto.empty:
-                    matches = df_crypto.to_dict("records")
-                    for m in matches: m["_category"] = "crypto"
-                    return matches
-            except Exception:
-                 pass
-            return []
-
-        def check_forex():
-            try:
-                forex_cols = get_default_columns_for_market("forex")
-                if include_technical: forex_cols.extend(technical_cols)
-                forex_cols = list(dict.fromkeys(forex_cols))
-
-                q_forex = (
-                    Query()
-                    .set_markets("forex")
-                    .select(*forex_cols)
-                    .where(Column("name").isin([symbol, symbol.upper()]))
-                    .limit(5)
-                )
-                _, df_forex = q_forex.get_scanner_data()
-                if not df_forex.empty:
-                    matches = df_forex.to_dict("records")
-                    for m in matches: m["_category"] = "forex"
-                    return matches
-            except Exception:
-                pass
-            return []
-
-        # Execute in parallel
-        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
-            futures = [
-                executor.submit(check_global_stocks),
-                executor.submit(check_crypto),
-                executor.submit(check_forex)
-            ]
-            for future in concurrent.futures.as_completed(futures):
-                all_matches.extend(future.result())
-
-        # --- Aggregate Results ---
-        if not all_matches:
-             # Try search_symbols as last resort (fuzzy search)
-             return search_symbols(symbol, "america", 5)
-
-        # Remove duplicates based on ticker
-        unique_matches = {}
-        for m in all_matches:
-            key = m.get("ticker", m.get("name"))
-            if key not in unique_matches:
-                unique_matches[key] = m
-        
-        final_matches = list(unique_matches.values())
-
-        if len(final_matches) == 1:
-            first = final_matches[0]
-            cat = first.pop("_category", "global")
-            return {"symbol": symbol, "found": True, "market": cat, "data": first}
-        
-        return {
-            "symbol": symbol,
-            "found": True, 
-            "market": "global", 
-            "count": len(final_matches),
-            "matches": final_matches,
-            "note": "Multiple matches found across global markets."
-        }
-
-    except Exception as e:
-        return {
-            "error": f"Failed to get symbol info: {str(e)}",
-            "hint": "Try using search_symbols to find the correct symbol format",
-        }