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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingview-mcp
-Version: 26.3.1
+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.1 → tradingview_mcp-26.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tradingview-mcp"
-version = "26.3.1"
+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.1 → 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.1 → 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.1 → tradingview_mcp-26.3.2}/src/tradingview_mcp/tools/search.py

@@ -55,13 +55,92 @@ def search_symbols(
 
     try:
         # Standard search in requested market
-        results = _execute_search(queries, 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
         
-        # Smart Fallback: If default market ('america') yielded no results, try others
+        # 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)
@@ -98,7 +177,7 @@ def search_symbols(
                      # Add locators for global results
                      records = df.to_dict("records")
                      for r in records:
-                          _enrich_locator(r, "stock", query) # We can't know exact market easily from batch query, assume global context usage
+                          _enrich_locator(r, "stock", query) 
                      
                      return {
                         "query": query,
@@ -111,18 +190,6 @@ def search_symbols(
             except Exception:
                 pass
 
-            # 3. Check Crypto/Forex/CFD
-            for other in ["crypto", "forex", "cfd"]:
-                 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" or other == "cfd": sort = "name"
-                 
-                 res = _execute_search(queries, other, 5, cols, sort)
-                 if res["results"]:
-                     return {**res, "note": f"Found matches in '{other}'."}
-
         return results
         
     except Exception as e:

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

@@ -25,7 +25,7 @@ def get_technical_analysis(symbol: str, market: str) -> dict[str, Any]:
     # Parse strictly formatted symbol
     exchange, ticker = symbol.split(":", 1)
     
-    market = sanitize_market(market)
+    market = sanitize_market(market, strict=True)
     
     # Use standard technical columns
     cols = list(TECHNICAL_COLUMNS)
@@ -60,7 +60,7 @@ def get_technical_analysis(symbol: str, market: str) -> dict[str, Any]:
 
 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()
@@ -100,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.
     
@@ -120,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.1 → tradingview_mcp-26.3.2}/src/tradingview_mcp/utils.py

@@ -99,33 +99,42 @@ COUNTRY_ALIASES = {
     "za": "rsa", # South Africa
 }
 
-def sanitize_market(market: str | None, default: str = "america") -> str:
+def sanitize_market(market: str | None, default: str = "america", strict: bool = False) -> str:
     """
     Validate and sanitize a market name.
     
     Args:
         market: Market to validate (e.g. 'america', 'tw', 'crypto')
-        default: Default value if invalid
+        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()
+    market_clean = market.strip().lower()
     
     # Check exact match
-    if market in MARKETS:
-        return market
+    if market_clean in MARKETS:
+        return market_clean
         
     # Check alias match
-    if market in COUNTRY_ALIASES:
-        return COUNTRY_ALIASES[market]
+    if market_clean in COUNTRY_ALIASES:
+        return COUNTRY_ALIASES[market_clean]
         
     # Check if user passed exchange (e.g. 'nasdaq') by mistake
-    if market in EXCHANGE_SCREENER:
-        return EXCHANGE_SCREENER[market]
+    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