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

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,31 @@ 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)
+        results = _execute_search(queries, 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)
+            # 1. Asian Numeric Heuristic
             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)
+                    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 +84,6 @@ def search_symbols(
                 _, df = q.get_scanner_data()
                 
                 if df.empty:
-                     # Check Name (Ticker)
                      q = (
                         Query()
                         .set_markets(*STOCK_MARKETS)
@@ -74,31 +95,33 @@ 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) # We can't know exact market easily from batch query, assume global context usage
+                     
                      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
+                pass
 
-            # 3. Check Crypto/Forex
-            for other in ["crypto", "forex"]:
+            # 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": sort = "name"
+                 if other == "forex" or other == "cfd": sort = "name"
                  
-                 res = _execute_search(query, other, 5, cols, sort)
+                 res = _execute_search(queries, other, 5, cols, sort)
                  if res["results"]:
-                     return {**res, "note": f"No results in stocks, found matches in '{other}'"}
+                     return {**res, "note": f"Found matches in '{other}'."}
 
         return results
         
@@ -106,74 +129,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]
+        
+    all_results = []
+    
+    # Try each query term until we get enough results
+    for q_term in queries:
+        if len(all_results) >= limit: break
         
-        # 2. If nothing found, search name (ticker)
-        if not results:
-            query_obj2 = (
+        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 +222,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 +240,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 +251,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,8 +6,25 @@ 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."""
+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)
     
     # Use standard 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 {

tradingview_mcp/utils.py

@@ -54,12 +54,57 @@ def sanitize_exchange(ex: str | None, default: str = "america") -> str:
     return default
 
 
+# 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") -> str:
     """
     Validate and sanitize a market name.
-
+    
     Args:
-        market: Market to validate
+        market: Market to validate (e.g. 'america', 'tw', 'crypto')
         default: Default value if invalid
 
     Returns:
@@ -67,8 +112,22 @@ def sanitize_market(market: str | None, default: str = "america") -> str:
     """
     if not market:
         return default
+    
     market = market.strip().lower()
-    return market if market in MARKETS else default
+    
+    # Check exact match
+    if market in MARKETS:
+        return market
+        
+    # Check alias match
+    if market in COUNTRY_ALIASES:
+        return COUNTRY_ALIASES[market]
+        
+    # Check if user passed exchange (e.g. 'nasdaq') by mistake
+    if market in EXCHANGE_SCREENER:
+        return EXCHANGE_SCREENER[market]
+
+    return default
 
 
 def timeframe_to_resolution(tf: str) -> str:

{tradingview_mcp-26.3.0.dist-info → tradingview_mcp-26.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingview-mcp
-Version: 26.3.0
+Version: 26.3.1
 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.1.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=5W0vLcrguwZv8q-ohZfQCqrkxVF1OCWPPVyCJ-bxhOo,11486
 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
@@ -35,10 +35,10 @@ tradingview_mcp/data/screeners/stocks_failed.json,sha256=RqBp9XCZ3xvdWZMwuVGysEE
 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/search.py,sha256=_BNdmf4qzUUG5A6orODzm3R2evDcdgBQhY6aRdg09-o,13791
+tradingview_mcp/tools/technical.py,sha256=x5raTT-l-Kn6uGUI_U7MLZRGjHXdgPB8Vss9nox3m5A,4500
+tradingview_mcp-26.3.1.dist-info/METADATA,sha256=XNaWsK_-K7ei3R8sLivRp4VPEYD4BewD_iCSePjOsXw,4818
+tradingview_mcp-26.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tradingview_mcp-26.3.1.dist-info/entry_points.txt,sha256=GZxjGqgVbUlWDp5OzFQoCN_g1UBLyOmfVqCR5uzscnU,57
+tradingview_mcp-26.3.1.dist-info/licenses/LICENSE,sha256=1Hdpp7qGWCXVw1BP6vpdAPO4KrgO0T_c0N3ipkYHKAo,1070
+tradingview_mcp-26.3.1.dist-info/RECORD,,