tradingview-mcp 26.3.0__py3-none-any.whl → 26.3.2__py3-none-any.whl

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/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/tools/search.py

@@ -10,14 +10,34 @@ from tradingview_mcp.docs_data import get_default_columns_for_market, STOCK_MARK
 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.
-    If default market returns no results, automatically searches crypto and forex.
+    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))
@@ -28,29 +48,110 @@ def search_symbols(
     # 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
-        results = _execute_search(query, market, limit, cols, sort_col)
+        # 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)
         
-        # Smart Fallback: If default market ('america') yielded no results, try others
+        # Fallback Logic (Only if truly empty)
         if not results["results"] and market == "america":
             
-            # 1. Asian Numeric Heuristic (Prioritized for speed/accuracy)
+            # 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" # Volume is good for general Asian scanners
-                    asian_res = _execute_search(query, asian_market, 5, asian_cols, asian_sort)
+                    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', found matches in '{asian_market}' (numeric heuristic)"}
+                         return {**asian_res, "note": f"No results in 'america', using numeric heuristic for '{asian_market}'."}
 
-            # 2. True Global Search (Check ALL 68+ Stock Markets)
+            # 2. True Global Search
             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)
@@ -62,7 +163,6 @@ def search_symbols(
                 _, df = q.get_scanner_data()
                 
                 if df.empty:
-                     # Check Name (Ticker)
                      q = (
                         Query()
                         .set_markets(*STOCK_MARKETS)
@@ -74,31 +174,21 @@ def search_symbols(
                      _, df = q.get_scanner_data()
                 
                 if not df.empty:
-                     # Basic Global Result
-                     total = len(df) # Roughly
+                     # 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": total,
+                        "total_found": len(df),
                         "returned": len(df),
-                        "results": df.to_dict("records"),
-                        "note": "No results in 'america', found matches in global stock markets."
+                        "results": records,
+                        "note": "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}'"}
+                pass
 
         return results
         
@@ -106,74 +196,86 @@ def search_symbols(
         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")
+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]
         
-        # 2. If nothing found, search name (ticker)
-        if not results:
-            query_obj2 = (
+    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("name").like(query))
+                .where(Column("description").like(q_term))
                 .order_by(sort_col, ascending=False)
                 .limit(limit)
             )
-            total, df = query_obj2.get_scanner_data()
-            results = df.to_dict("records")
+            _, df = q.get_scanner_data()
+            if not df.empty:
+                 all_results.extend(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}
+            # 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]:
-    """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}
+    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.
+    Returns matches with strict locators: 'EXCHANGE:SYMBOL, Market'.
     """
     technical_cols = [
         "RSI", "RSI7", "MACD.macd", "MACD.signal", "SMA20", "SMA50", "SMA200", 
@@ -187,12 +289,13 @@ def get_symbol_info(symbol: str, include_technical: bool = False) -> dict[str, A
             exchange, ticker = symbol.split(":", 1)
             market = EXCHANGE_SCREENER.get(exchange.lower()) or "america"
             
-            # Setup Columns
+            # 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))
 
-            # Query
             q = (
                 Query()
                 .set_markets(market)
@@ -204,6 +307,10 @@ def get_symbol_info(symbol: str, include_technical: bool = False) -> dict[str, A
             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}
@@ -211,92 +318,76 @@ def get_symbol_info(symbol: str, include_technical: bool = False) -> dict[str, A
                 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))
+        # 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))
                 
-                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"
+                # 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 Exception:
+             except:
                  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 []
+             return []
 
         # Execute in parallel
-        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
             futures = [
-                executor.submit(check_global_stocks),
-                executor.submit(check_crypto),
-                executor.submit(check_forex)
+                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:
-             # Try search_symbols as last resort (fuzzy search)
              return search_symbols(symbol, "america", 5)
 
-        # Remove duplicates based on ticker
+        # Remove duplicates
         unique_matches = {}
         for m in all_matches:
             key = m.get("ticker", m.get("name"))

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/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.dist-info → tradingview_mcp-26.3.2.dist-info}/METADATA

@@ -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.dist-info → tradingview_mcp-26.3.2.dist-info}/RECORD

@@ -7,7 +7,7 @@ tradingview_mcp/query.py,sha256=gkC4t-2_jtuUK3KgzU62wrIcGoaOmY--1EwAshGQb0Q,1087
 tradingview_mcp/resources.py,sha256=6cbsPhXsq6SFh3bmmSnMtrVkyCx1_xpWWiyqNLCCULk,1910
 tradingview_mcp/scanner.py,sha256=oEfMzaYhQ7ggBdLlPLqKZCMxHkd6MBMaUMcm3p-YvPA,7649
 tradingview_mcp/server.py,sha256=opC61fKfchYn3-XL5ZlPGvsPRZZoLXe-VqGSulhrJHA,7165
-tradingview_mcp/utils.py,sha256=6O89qIaZ_eYoN3m12r2q4-D8VpJajP5WuwKQbj4ZVHo,10238
+tradingview_mcp/utils.py,sha256=My7SdEz89xfAW8aDsxoK311PGCd6kMFmg2DW2udM098,12007
 tradingview_mcp/data/__init__.py,sha256=3kot_ZG4a6jbZgyksE9z56n3skI407lsd4y2ThHotKY,298
 tradingview_mcp/data/column_display_names.json,sha256=AFdo6Q2n-wSXWHi2wEExOd2pTItyjocRbrnxqYpCa94,30137
 tradingview_mcp/data/markets.json,sha256=CehqCeVdQhWeCkMX1HWOrgCRjOomWa3VH1v2ZvPnIck,1482
@@ -33,12 +33,12 @@ tradingview_mcp/data/screeners/markets.json,sha256=vpdrAKg4E_lgg4FxeX2GHNbnSsKQD
 tradingview_mcp/data/screeners/stocks.json,sha256=gCnntHTJKJ7n7IqY72fZ4EuBfthtnWUpfHvPqNOvnXo,8843
 tradingview_mcp/data/screeners/stocks_failed.json,sha256=RqBp9XCZ3xvdWZMwuVGysEE2Er_XOQvBZoUHo9uyj6k,1084574
 tradingview_mcp/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tradingview_mcp/tools/reference.py,sha256=BPip9ntzyRwIyE0SoD8TWqSGLYj7Evt-OM1SQ1uPG8o,2160
-tradingview_mcp/tools/screener.py,sha256=K6uOUFq4GzPeCE4w2oa1LkAHbodQdQcmexw0W3sofeo,3188
-tradingview_mcp/tools/search.py,sha256=40Wpcf-noEkcB8Yv3f1NPd0UtmixWEf_AZoGf_GGibM,12970
-tradingview_mcp/tools/technical.py,sha256=l5nhXLQu-5iGJ0G-pdVFAghQsXv7JqoEGlphqrEjxQ8,3620
-tradingview_mcp-26.3.0.dist-info/METADATA,sha256=pBPcg95atEn_vedXIz7dwJ3WWeVgCv6HCT1xWjsQ3bU,4818
-tradingview_mcp-26.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tradingview_mcp-26.3.0.dist-info/entry_points.txt,sha256=GZxjGqgVbUlWDp5OzFQoCN_g1UBLyOmfVqCR5uzscnU,57
-tradingview_mcp-26.3.0.dist-info/licenses/LICENSE,sha256=1Hdpp7qGWCXVw1BP6vpdAPO4KrgO0T_c0N3ipkYHKAo,1070
-tradingview_mcp-26.3.0.dist-info/RECORD,,
+tradingview_mcp/tools/reference.py,sha256=Oyc-l2ogjk2Evvqwk4SzgpGFV0vKKkdKJwQJmJbLJrM,2751
+tradingview_mcp/tools/screener.py,sha256=5n-p-yXSljm9uqEfQmeg3EpDq2alDywrptvaxJaYMz8,3240
+tradingview_mcp/tools/search.py,sha256=3uSGKfmKpI6ysc8v4hOLin3XAAKcQHeTBzzFSudt1hw,16328
+tradingview_mcp/tools/technical.py,sha256=8oIrag7qnGltdsbIOkLkKtAUOHRYrp7RMV7Er5X_jAY,4552
+tradingview_mcp-26.3.2.dist-info/METADATA,sha256=OcI-yg571T3ToHOe0Zwf4KW09xAclsPqJab3c6hoy1g,4818
+tradingview_mcp-26.3.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tradingview_mcp-26.3.2.dist-info/entry_points.txt,sha256=GZxjGqgVbUlWDp5OzFQoCN_g1UBLyOmfVqCR5uzscnU,57
+tradingview_mcp-26.3.2.dist-info/licenses/LICENSE,sha256=1Hdpp7qGWCXVw1BP6vpdAPO4KrgO0T_c0N3ipkYHKAo,1070
+tradingview_mcp-26.3.2.dist-info/RECORD,,