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

tradingview_mcp/tools/reference.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+from typing import Any, Optional
+
+from tradingview_mcp.docs_data import (
+    get_ai_quick_reference,
+    search_fields,
+    get_screener_code_examples,
+    get_valid_fields_for_market,
+    get_common_fields,
+    lookup_field,
+    get_field_summary,
+    get_filter_format,
+    validate_market,
+    get_quick_reference,
+    get_screener_presets,
+    get_metainfo
+)
+
+def ai_get_reference() -> dict[str, Any]:
+    """Get AI quick reference for using this MCP."""
+    return get_ai_quick_reference()
+
+def search_available_fields(query: str, market: str = None) -> list[dict[str, Any]]:
+    """Search for available fields/columns."""
+    return search_fields(query, market)
+
+def get_code_example(name: str) -> str:
+    """Get code example by name."""
+    examples = get_screener_code_examples()
+    return examples.get(name, "Example not found.")
+
+def list_fields_for_market(market: str) -> list[str]:
+    """List valid fields for a specific market."""
+    return get_valid_fields_for_market(market)
+
+def get_common_fields_summary() -> dict[str, Any]:
+    """Get summary of common fields."""
+    return get_common_fields()
+
+def lookup_single_field(name: str) -> dict[str, Any]:
+    """Lookup details for a single field."""
+    return lookup_field(name)
+
+def get_field_info(name: str) -> dict[str, Any]:
+    """Get info for a field."""
+    return get_field_summary(name) or {"error": "Field not found"}
+
+def get_filter_example(type: str = "number") -> dict[str, Any]:
+    """Get example filter format."""
+    return get_filter_format(type)
+
+def check_market(market: str) -> dict[str, Any]:
+    """Validate a market name."""
+    return validate_market(market)
+
+def get_help() -> dict[str, Any]:
+    """Get help and usage info."""
+    return get_quick_reference()
+
+def get_screener_preset(name: str) -> dict[str, Any]:
+    """Get a screener preset."""
+    presets = get_screener_presets()
+    for p in presets:
+        if p.get("name") == name:
+            return p
+    return {"error": "Preset not found"}
+
+def get_market_metainfo(market: str) -> dict[str, Any]:
+    """Get metainfo for a market."""
+    return get_metainfo(market)

tradingview_mcp/tools/screener.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+from typing import Any, Optional
+
+from tradingview_mcp.column import Column
+from tradingview_mcp.constants import DEFAULT_COLUMNS, get_column_name
+from tradingview_mcp.query import Query
+from tradingview_mcp.utils import sanitize_market
+
+def screen_market(
+    market: str = "america",
+    columns: Optional[list[str]] = None,
+    sort_by: str = "volume",
+    ascending: bool = False,
+    limit: int = 25,
+    filters: Optional[list[dict[str, Any]]] = None,
+) -> dict[str, Any]:
+    """Run a custom market screening query."""
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 500))
+    
+    # Ensure description is always included
+    cols = columns or DEFAULT_COLUMNS
+    if "description" not in cols:
+        cols = ["description"] + list(cols)
+
+    query = Query().set_markets(market).select(*cols).order_by(sort_by, ascending=ascending).limit(limit)
+
+    # Apply filters if provided
+    if filters:
+        filter_expressions = []
+        for f in filters:
+            # Automatic translation of human-readable column names
+            col_name = get_column_name(f.get("column", "close"))
+            col = Column(col_name)
+            op = f.get("operation", "gt")
+            val = f.get("value")
+
+            if op == "gt":
+                filter_expressions.append(col > val)
+            elif op == "gte":
+                filter_expressions.append(col >= val)
+            elif op == "lt":
+                filter_expressions.append(col < val)
+            elif op == "lte":
+                filter_expressions.append(col <= val)
+            elif op == "eq":
+                filter_expressions.append(col == val)
+            elif op == "neq":
+                filter_expressions.append(col != val)
+            elif op == "between" and isinstance(val, (list, tuple)) and len(val) == 2:
+                filter_expressions.append(col.between(val[0], val[1]))
+            elif op == "isin" and isinstance(val, (list, tuple)):
+                filter_expressions.append(col.isin(val))
+
+        if filter_expressions:
+            query = query.where(*filter_expressions)
+
+    try:
+        total_count, df = query.get_scanner_data()
+        results = df.to_dict("records")
+
+        return {
+            "total_count": total_count,
+            "returned": len(results),
+            "market": market,
+            "data": results,
+        }
+    except Exception as e:
+        return {"error": str(e), "market": market}
+
+
+def get_top_gainers(market: str = "america", limit: int = 25) -> dict[str, Any]:
+    """Get top gainers for a market."""
+    market = sanitize_market(market)
+    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)
+    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)
+    return screen_market(market, sort_by="volume", ascending=False, limit=limit)

tradingview_mcp/tools/search.py

@@ -0,0 +1,326 @@
+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",
+        }

tradingview_mcp/tools/technical.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+from typing import Any
+
+from tradingview_mcp.column import Column
+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)
+    
+    # Use standard technical columns
+    cols = list(TECHNICAL_COLUMNS)
+    
+    try:
+        q = (
+            Query()
+            .set_markets(market)
+            .select(*cols)
+            .where(Column("name").isin([symbol, symbol.upper()]))
+            .limit(1)
+        )
+        _, df = q.get_scanner_data()
+        
+        if df.empty:
+            return {"error": f"Symbol {symbol} not found in {market}"}
+            
+        data = df.iloc[0].to_dict()
+        return {
+            "symbol": symbol,
+            "market": market,
+            "indicators": data
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+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)
+    
+    q = (
+        Query()
+        .set_markets(market)
+        .select("name", "close", "RSI", "volume")
+        # RSI > 70 OR RSI < 30. Note: Current Query builder supports AND by default.
+        # For OR logic, we might need multiple queries or where2 if supported.
+        # Let's simple check oversold first (<30)
+        .where(Column("RSI") < 30)
+        .order_by("RSI", ascending=True)
+        .limit(limit)
+    )
+    
+    try:
+        _, df_oversold = q.get_scanner_data()
+        oversold = df_oversold.to_dict("records")
+        
+        # Overbought
+        q2 = (
+            Query()
+            .set_markets(market)
+            .select("name", "close", "RSI", "volume")
+            .where(Column("RSI") > 70)
+            .order_by("RSI", ascending=False)
+            .limit(limit)
+        )
+        _, df_overbought = q2.get_scanner_data()
+        overbought = df_overbought.to_dict("records")
+        
+        return {
+            "market": market,
+            "oversold": oversold,
+            "overbought": overbought
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+def scan_bollinger_bands(market: str = "america", limit: int = 25) -> dict[str, Any]:
+    """Find symbols trading outside Bollinger Bands."""
+    market = sanitize_market(market)
+    # This is complex to do with simple filters.
+    # We'll just return basic BB values for top volume stocks.
+    
+    q = (
+        Query()
+        .set_markets(market)
+        .select("name", "close", "BB.upper", "BB.lower")
+        .order_by("volume", ascending=False)
+        .limit(limit)
+    )
+    
+    try:
+        _, df = q.get_scanner_data()
+        return {"data": df.to_dict("records")}
+    except Exception as e:
+        return {"error": str(e)}
+
+def scan_macd_crossover(market: str = "america", limit: int = 25) -> dict[str, Any]:
+    """scan for MACD crossovers."""
+    market = sanitize_market(market)
+    q = (
+        Query()
+        .set_markets(market)
+        .select("name", "close", "MACD.macd", "MACD.signal")
+        .where(Column("MACD.macd") > Column("MACD.signal")) # Bullish crossoverish (simple comparison)
+        .order_by("volume", ascending=False)
+        .limit(limit)
+    )
+    try:
+        _, df = q.get_scanner_data()
+        return {"bullish_macd_momentum": df.to_dict("records")}
+    except Exception as e:
+        return {"error": str(e)}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingview-mcp
-Version: 26.2.0
+Version: 26.3.0
 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
@@ -43,7 +43,6 @@ Description-Content-Type: text/markdown
 MCP server for TradingView market screening. Supports stocks, crypto, forex, futures, bonds across 76+ markets.
 
 ## Quick Start
-
 ```json
 {
   "mcpServers": {
@@ -55,6 +54,12 @@ MCP server for TradingView market screening. Supports stocks, crypto, forex, fut
 }
 ```
 
+## Smart Features
+
+- **Auto-Market Detection**: If you search for `EURUSD` or `BTCUSDT`, the server automatically checks Forex and Crypto markets if not found in stocks.
+- **Strict Exchange Support**: Use `EXCHANGE:SYMBOL` format (e.g., `BINANCE:BTCUSDT`, `FX:EURUSD`) to target specific markets.
+- **Smart Filters**: You can use human-readable names in filters (e.g., `"Relative Strength Index (14)"` instead of `"RSI"`).
+
 ## Main Tools
 
 | Tool | Description |
@@ -87,7 +92,9 @@ MCP server for TradingView market screening. Supports stocks, crypto, forex, fut
 | `list_fields_for_market` | List fields for a market |
 | `get_screener_preset` | Get predefined screener presets |
 
-## Resources
+## Reference Resources
+
+These resources provide raw lists of available markets and fields for reference.
 
 | Resource | Description |
 |----------|-------------|

{tradingview_mcp-26.2.0.dist-info → tradingview_mcp-26.3.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
 tradingview_mcp/__init__.py,sha256=V7RLq22Qp1rsMhDYNlXfWkiNaXlo7s4KkNUmSvbGKIM,455
 tradingview_mcp/column.py,sha256=MC7lWksmyaYF4SkVm97Apr8httwip-N-4aVTSyS0CQo,8871
-tradingview_mcp/constants.py,sha256=kQUhcG0U1cVLiN6LGgzWPjCGhXh_-jvB5lF15QIX1_4,12927
-tradingview_mcp/docs_data.py,sha256=4mhaO-far90SSXzSl1fLZIzNBe0lOTxFeX7ITzYTBpo,17698
+tradingview_mcp/constants.py,sha256=RlhAbBSbOUUJejyTiYozNjCD29TimVTC-ok2HkDzi_s,5417
+tradingview_mcp/docs_data.py,sha256=PYMZxC2Y6Xqcv4XP2Z7pIKzNSokW440Zq68H5fgSASs,19118
 tradingview_mcp/models.py,sha256=CHSQ46A2ljhvzI6YP8XRItUdoDJw1yYebiBANt9xeD0,3366
 tradingview_mcp/query.py,sha256=gkC4t-2_jtuUK3KgzU62wrIcGoaOmY--1EwAshGQb0Q,10871
+tradingview_mcp/resources.py,sha256=6cbsPhXsq6SFh3bmmSnMtrVkyCx1_xpWWiyqNLCCULk,1910
 tradingview_mcp/scanner.py,sha256=oEfMzaYhQ7ggBdLlPLqKZCMxHkd6MBMaUMcm3p-YvPA,7649
-tradingview_mcp/server.py,sha256=WdBov_EoJGA_BNurf1PJ6m6_ZayztjqqniItOvudkPY,51698
+tradingview_mcp/server.py,sha256=opC61fKfchYn3-XL5ZlPGvsPRZZoLXe-VqGSulhrJHA,7165
 tradingview_mcp/utils.py,sha256=6O89qIaZ_eYoN3m12r2q4-D8VpJajP5WuwKQbj4ZVHo,10238
 tradingview_mcp/data/__init__.py,sha256=3kot_ZG4a6jbZgyksE9z56n3skI407lsd4y2ThHotKY,298
 tradingview_mcp/data/column_display_names.json,sha256=AFdo6Q2n-wSXWHi2wEExOd2pTItyjocRbrnxqYpCa94,30137
@@ -31,8 +32,13 @@ tradingview_mcp/data/screeners/main_screeners.json,sha256=kU_xGJ7ePoGN3s8g9PwGrc
 tradingview_mcp/data/screeners/markets.json,sha256=vpdrAKg4E_lgg4FxeX2GHNbnSsKQDmgfnyr2ziSdQsk,1004
 tradingview_mcp/data/screeners/stocks.json,sha256=gCnntHTJKJ7n7IqY72fZ4EuBfthtnWUpfHvPqNOvnXo,8843
 tradingview_mcp/data/screeners/stocks_failed.json,sha256=RqBp9XCZ3xvdWZMwuVGysEE2Er_XOQvBZoUHo9uyj6k,1084574
-tradingview_mcp-26.2.0.dist-info/METADATA,sha256=ayxnek_OIGlG_IpQZTsE_jmR7J0LljnN1STnzVQxC3o,4303
-tradingview_mcp-26.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tradingview_mcp-26.2.0.dist-info/entry_points.txt,sha256=GZxjGqgVbUlWDp5OzFQoCN_g1UBLyOmfVqCR5uzscnU,57
-tradingview_mcp-26.2.0.dist-info/licenses/LICENSE,sha256=1Hdpp7qGWCXVw1BP6vpdAPO4KrgO0T_c0N3ipkYHKAo,1070
-tradingview_mcp-26.2.0.dist-info/RECORD,,
+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,,