@kuandotdev/indicator 0.1.1 → 0.1.3

package/project/src/tv_indicator/cli/pine_cmds.py

@@ -0,0 +1,140 @@
+"""`training-view pine ...` subcommands — local Pine scaffolding / validation."""
+from __future__ import annotations
+
+import re
+from datetime import date
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from ..config import settings, PROJECT_ROOT
+
+app = typer.Typer(no_args_is_help=True, help="Scaffold and validate PineScript locally.")
+console = Console()
+
+_TEMPLATE_DIR = PROJECT_ROOT / "skills" / "pinescript-v6" / "reference" / "templates"
+
+
+@app.command()
+def new(
+    kind: str = typer.Argument(..., help="indicator | strategy | webhook"),
+    name: str = typer.Argument(..., help="snake_case file name (no .pine)"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite if exists"),
+) -> None:
+    """Scaffold a new .pine file from the v6 template."""
+    kind = kind.lower()
+    template_map = {
+        "indicator": ("indicator.pine", "indicators"),
+        "strategy": ("strategy.pine", "strategies"),
+        "webhook": ("alert-webhook.pine", "strategies"),
+    }
+    if kind not in template_map:
+        console.print(f"[red]Unknown kind '{kind}'. Use: indicator | strategy | webhook[/red]")
+        raise typer.Exit(1)
+
+    tpl_name, subdir = template_map[kind]
+    tpl_path = _TEMPLATE_DIR / tpl_name
+    if not tpl_path.exists():
+        console.print(f"[red]Template not found:[/red] {tpl_path}")
+        raise typer.Exit(1)
+
+    out_dir = settings.scripts_dir / subdir
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / f"{name}.pine"
+    if out_path.exists() and not force:
+        console.print(f"[yellow]Exists:[/yellow] {out_path} (use --force to overwrite)")
+        raise typer.Exit(1)
+
+    content = tpl_path.read_text(encoding="utf-8")
+    # Substitute placeholders
+    title = name.replace("_", " ").title()
+    content = content.replace("<Indicator Name>", title)
+    content = content.replace("<Strategy Name>", title)
+    content = content.replace("<short>", name[:10])
+    content = content.replace("<user>", settings.tv_username or "me")
+    content = content.replace("<date>", date.today().isoformat())
+    content = content.replace("<one-paragraph description>", "TODO: describe.")
+    content = content.replace("<one-paragraph description of entry/exit logic>", "TODO: describe.")
+
+    out_path.write_text(content, encoding="utf-8")
+    console.print(f"[green]Created:[/green] {out_path}")
+
+
+@app.command()
+def validate(
+    script: Path = typer.Argument(..., exists=True, help="Path to .pine file"),
+) -> None:
+    """Run lightweight local checks (real validation happens in TV's compiler)."""
+    code = script.read_text(encoding="utf-8")
+    issues: list[str] = []
+
+    if not re.search(r"^//@version=\d+", code, re.M):
+        issues.append("Missing `//@version=N` directive.")
+    else:
+        m = re.search(r"^//@version=(\d+)", code, re.M)
+        if m and m.group(1) not in {"5", "6"}:
+            issues.append(f"Version {m.group(1)} detected; prefer v6.")
+
+    decls = sum(
+        1 for kw in ("indicator(", "strategy(", "library(")
+        if re.search(rf"^\s*{re.escape(kw)}", code, re.M)
+    )
+    if decls == 0:
+        issues.append("No `indicator()`, `strategy()`, or `library()` declaration found.")
+    elif decls > 1:
+        issues.append(f"{decls} declaration calls found; exactly one is required.")
+
+    # Check for unprefixed legacy calls
+    legacy_calls = ["sma(", "ema(", "rma(", "wma(", "rsi(", "atr(", "highest(", "lowest(",
+                    "crossover(", "crossunder(", "tostring(", "abs("]
+    for fn in legacy_calls:
+        # Match call NOT preceded by '.' or letter
+        if re.search(rf"(?<![.\w]){re.escape(fn)}", code):
+            ns = "ta." if fn[:-1] in {"sma", "ema", "rma", "wma", "rsi", "atr",
+                                       "highest", "lowest", "crossover", "crossunder"} \
+                else "str." if fn[:-1] in {"tostring"} \
+                else "math." if fn[:-1] in {"abs"} \
+                else "?."
+            issues.append(f"Use `{ns}{fn}` instead of unprefixed `{fn}` (v5/v6 requires namespace).")
+
+    # Indicator must have at least one plot-like
+    if "indicator(" in code:
+        if not re.search(r"\b(plot|plotshape|plotchar|bgcolor|hline)\s*\(", code):
+            issues.append("indicator() has no plot*/bgcolor/hline output.")
+
+    # Strategy must have at least one entry
+    if "strategy(" in code and not re.search(r"\bstrategy\.(entry|order|close)\b", code):
+        issues.append("strategy() has no strategy.entry/order/close calls.")
+
+    if issues:
+        console.print(f"[yellow]Found {len(issues)} potential issue(s):[/yellow]")
+        for i in issues:
+            console.print(f"  • {i}")
+        raise typer.Exit(2)
+    else:
+        console.print(f"[green]✅ {script} looks OK (basic checks).[/green]")
+        console.print("[dim]   Real validation requires TradingView's Pine compiler.[/dim]")
+
+
+@app.command(name="list")
+def list_scripts() -> None:
+    """List all local .pine files."""
+    found = sorted(settings.scripts_dir.rglob("*.pine"))
+    if not found:
+        console.print(f"[yellow]No .pine files under {settings.scripts_dir}[/yellow]")
+        return
+    for p in found:
+        console.print(f"  {p.relative_to(PROJECT_ROOT)}")
+
+
+@app.command()
+def show(
+    script: Path = typer.Argument(..., exists=True),
+) -> None:
+    """Print a Pine script with syntax-aware coloring (rough)."""
+    from rich.syntax import Syntax
+
+    code = script.read_text(encoding="utf-8")
+    # No Pine lexer in Pygments; JS is the closest visual approximation
+    console.print(Syntax(code, "javascript", line_numbers=True, theme="monokai"))

package/project/src/tv_indicator/config.py

@@ -0,0 +1,98 @@
+"""Centralized configuration: env loading, paths, TV session cookie handling.
+
+Both the CLI and the MCP servers import from here so behaviour stays consistent.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+# Walk up from this file until we find a .env, or land at project root
+_HERE = Path(__file__).resolve()
+PROJECT_ROOT = _HERE.parents[2]  # src/tv_indicator/config.py -> project/
+load_dotenv(PROJECT_ROOT / ".env", override=False)
+
+
+@dataclass(frozen=True)
+class Settings:
+    # TradingView authentication
+    tv_sessionid: str | None
+    tv_sessionid_sign: str | None
+    tv_username: str | None
+
+    # Browser automation
+    browser_profile: Path
+    browser_headless: bool
+    default_chart_url: str | None
+
+    # Output dirs
+    screenshot_dir: Path
+    scripts_dir: Path
+
+    @property
+    def has_session(self) -> bool:
+        return bool(self.tv_sessionid)
+
+    def session_cookies(self) -> list[dict]:
+        """Format cookies for Playwright's `context.add_cookies()`."""
+        cookies: list[dict] = []
+        if self.tv_sessionid:
+            cookies.append({
+                "name": "sessionid",
+                "value": self.tv_sessionid,
+                "domain": ".tradingview.com",
+                "path": "/",
+                "httpOnly": True,
+                "secure": True,
+                "sameSite": "Lax",
+            })
+        if self.tv_sessionid_sign:
+            cookies.append({
+                "name": "sessionid_sign",
+                "value": self.tv_sessionid_sign,
+                "domain": ".tradingview.com",
+                "path": "/",
+                "httpOnly": True,
+                "secure": True,
+                "sameSite": "Lax",
+            })
+        return cookies
+
+
+def _bool_env(key: str, default: bool) -> bool:
+    raw = os.getenv(key)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on", "y"}
+
+
+def _path_env(key: str, default: Path) -> Path:
+    raw = os.getenv(key)
+    if raw is None or not raw.strip():
+        return default
+    p = Path(raw).expanduser()
+    if not p.is_absolute():
+        p = (PROJECT_ROOT / p).resolve()
+    return p
+
+
+def load_settings() -> Settings:
+    return Settings(
+        tv_sessionid=os.getenv("TV_SESSIONID") or None,
+        tv_sessionid_sign=os.getenv("TV_SESSIONID_SIGN") or None,
+        tv_username=os.getenv("TV_USERNAME") or None,
+        browser_profile=_path_env(
+            "TV_BROWSER_PROFILE", PROJECT_ROOT / "tools/tv_browser/sessions/default"
+        ),
+        browser_headless=_bool_env("TV_BROWSER_HEADLESS", True),
+        default_chart_url=os.getenv("TV_DEFAULT_CHART_URL") or None,
+        screenshot_dir=_path_env("TV_SCREENSHOT_DIR", PROJECT_ROOT / "screenshots"),
+        scripts_dir=_path_env("TV_SCRIPTS_DIR", PROJECT_ROOT / "scripts"),
+    )
+
+
+# Singleton for convenience
+settings = load_settings()

package/project/src/tv_indicator/data/client.py

@@ -0,0 +1,187 @@
+"""OHLCV data via tvdatafeed (reverse-engineered TV WebSocket).
+
+⚠️  tvdatafeed is not on PyPI in a maintained form. Install via:
+    pip install --upgrade --force-reinstall git+https://github.com/rongardF/tvdatafeed.git
+
+This wrapper hides the import error until the function is actually called so the
+rest of the CLI still works without the optional dependency.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+import pandas as pd
+
+from ..config import settings
+
+
+class Interval(str, Enum):
+    M_1 = "1"
+    M_3 = "3"
+    M_5 = "5"
+    M_15 = "15"
+    M_30 = "30"
+    M_45 = "45"
+    H_1 = "60"
+    H_2 = "120"
+    H_3 = "180"
+    H_4 = "240"
+    D = "1D"
+    W = "1W"
+    MN = "1M"
+
+
+# Map our string interval to tvdatafeed's Interval enum at call time
+_TV_INTERVAL_MAP = {
+    "1": "in_1_minute",
+    "3": "in_3_minute",
+    "5": "in_5_minute",
+    "15": "in_15_minute",
+    "30": "in_30_minute",
+    "45": "in_45_minute",
+    "60": "in_1_hour",
+    "120": "in_2_hour",
+    "180": "in_3_hour",
+    "240": "in_4_hour",
+    "1D": "in_daily",
+    "1W": "in_weekly",
+    "1M": "in_monthly",
+}
+
+# Friendly aliases -> canonical TV codes
+_INTERVAL_ALIASES = {
+    "1m": "1", "3m": "3", "5m": "5", "15m": "15", "30m": "30", "45m": "45",
+    "1h": "60", "60m": "60",
+    "2h": "120", "3h": "180", "4h": "240",
+    "1d": "1D", "d": "1D", "day": "1D", "daily": "1D",
+    "1w": "1W", "w": "1W", "week": "1W", "weekly": "1W",
+    "1mo": "1M", "mo": "1M", "month": "1M", "monthly": "1M",
+}
+
+
+def _normalize_interval(interval: str) -> str:
+    """Map user-friendly intervals (e.g. '1H', '4h', 'daily') to TV codes ('60', '240', '1D')."""
+    if interval in _TV_INTERVAL_MAP:
+        return interval
+    alias = _INTERVAL_ALIASES.get(interval.lower())
+    if alias is not None:
+        return alias
+    return interval  # let downstream raise a clear error
+
+
+@dataclass
+class OHLCVRequest:
+    symbol: str  # e.g. "AAPL" or "NASDAQ:AAPL"
+    exchange: Optional[str] = None  # if not encoded in symbol
+    interval: str = "1D"
+    n_bars: int = 500
+    extended_session: bool = False
+    fut_contract: Optional[int] = None  # for futures, None for spot/stock
+
+
+def _split_symbol(symbol: str, exchange: Optional[str]) -> tuple[str, str]:
+    """Accept 'NASDAQ:AAPL' or ('AAPL', 'NASDAQ'); return (symbol, exchange)."""
+    if ":" in symbol:
+        ex, sym = symbol.split(":", 1)
+        return sym, ex
+    if exchange:
+        return symbol, exchange
+    # Sensible default for stocks; users should always be explicit
+    return symbol, "NASDAQ"
+
+
+class TVDataClient:
+    """Thin wrapper around tvdatafeed.TvDatafeed.
+
+    Lazily constructed so that import failures only surface when actually used.
+    """
+
+    _instance: Optional["TVDataClient"] = None
+
+    def __init__(self) -> None:
+        try:
+            # Both capitalisations are used in different forks
+            try:
+                from tvDatafeed import TvDatafeed, Interval as TVInterval  # type: ignore
+            except ImportError:
+                from tvdatafeed import TvDatafeed, Interval as TVInterval  # type: ignore
+        except ImportError as e:
+            raise RuntimeError(
+                "tvdatafeed is not installed.\n"
+                "  pip install git+https://github.com/rongardF/tvdatafeed.git"
+            ) from e
+
+        self._TVInterval = TVInterval
+
+        if settings.tv_username and settings.tv_sessionid:
+            # The maintained fork takes a token/session — pattern varies.
+            # Default to anonymous mode; user can subclass or extend if needed.
+            self._tv = TvDatafeed()
+        else:
+            self._tv = TvDatafeed()
+
+    @classmethod
+    def get(cls) -> "TVDataClient":
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def get_ohlcv(self, req: OHLCVRequest, retries: int = 2) -> pd.DataFrame:
+        """Fetch OHLCV with auto-retry on transient WebSocket drops.
+
+        tvDatafeed occasionally returns empty results when its WebSocket connection
+        is lost on first contact ("Connection to remote host was lost"). We retry up
+        to `retries` times with a short backoff.
+        """
+        symbol, exchange = _split_symbol(req.symbol, req.exchange)
+        canonical = _normalize_interval(req.interval)
+        tv_interval_name = _TV_INTERVAL_MAP.get(canonical)
+        if tv_interval_name is None:
+            raise ValueError(
+                f"Unsupported interval '{req.interval}'. "
+                f"Valid: {list(_TV_INTERVAL_MAP.keys())}"
+            )
+        interval = getattr(self._TVInterval, tv_interval_name)
+
+        attempts = max(1, retries + 1)
+        last_df: Optional[pd.DataFrame] = None
+        for attempt in range(1, attempts + 1):
+            try:
+                df = self._tv.get_hist(
+                    symbol=symbol,
+                    exchange=exchange,
+                    interval=interval,
+                    n_bars=req.n_bars,
+                    fut_contract=req.fut_contract,
+                    extended_session=req.extended_session,
+                )
+            except Exception:
+                df = None
+            if df is not None and not df.empty:
+                return df
+            last_df = df
+            if attempt < attempts:
+                time.sleep(0.8 * attempt)
+        # All retries exhausted -> empty frame
+        return pd.DataFrame(columns=["open", "high", "low", "close", "volume"]) if last_df is None or last_df.empty else last_df
+
+
+def get_ohlcv(
+    symbol: str,
+    interval: str = "1D",
+    n_bars: int = 500,
+    exchange: Optional[str] = None,
+    extended_session: bool = False,
+) -> pd.DataFrame:
+    """Functional wrapper used by CLI and MCP."""
+    req = OHLCVRequest(
+        symbol=symbol,
+        exchange=exchange,
+        interval=interval,
+        n_bars=n_bars,
+        extended_session=extended_session,
+    )
+    return TVDataClient.get().get_ohlcv(req)

package/project/src/tv_indicator/data/screener.py

@@ -0,0 +1,268 @@
+"""Symbol search + screener via `tradingview-screener` (most reliable TV endpoint).
+
+This library uses TV's public scanner endpoint, which doesn't require auth.
+Good for: searching tickers, running filter queries, getting TV's technical
+ratings across many symbols at once.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any, Iterable, Optional
+
+import pandas as pd
+
+
+def _taiwan_direct_candidates(query: str) -> list[tuple[str, str]]:
+    """Return direct TWSE/TPEX candidates for Taiwan-style numeric tickers."""
+    q = query.strip().upper()
+    if q.endswith(".TW"):
+        ticker = q.removesuffix(".TW")
+        return [(ticker, "TWSE")] if ticker.isdigit() else []
+    if q.endswith(".TWO"):
+        ticker = q.removesuffix(".TWO")
+        return [(ticker, "TPEX")] if ticker.isdigit() else []
+    if q.isdigit() and 4 <= len(q) <= 6:
+        return [(q, "TWSE"), (q, "TPEX")]
+    return []
+
+
+def _verified_taiwan_matches(query: str, limit: int) -> list[dict[str, Any]]:
+    """Fallback for symbols missing from scanner search, e.g. 0050 and 6584."""
+    candidates = _taiwan_direct_candidates(query)
+    if not candidates:
+        return []
+
+    try:
+        from .client import OHLCVRequest, TVDataClient
+    except Exception:
+        return []
+
+    matches: list[dict[str, Any]] = []
+    for ticker, exchange in candidates:
+        symbol = f"{exchange}:{ticker}"
+        tv_logger = logging.getLogger("tvDatafeed.main")
+        was_disabled = tv_logger.disabled
+        try:
+            tv_logger.disabled = True
+            df = TVDataClient.get().get_ohlcv(
+                OHLCVRequest(symbol=symbol, interval="1D", n_bars=1),
+                retries=0,
+            )
+        except Exception:
+            continue
+        finally:
+            tv_logger.disabled = was_disabled
+        if df is None or df.empty:
+            continue
+        matches.append(
+            {
+                "name": ticker,
+                "description": f"{ticker} Taiwan security",
+                "type": "stock",
+                "exchange": exchange,
+                "country": "Taiwan",
+                "symbol": symbol,
+            }
+        )
+        break
+    return matches
+
+
+def search_symbol(query: str, limit: int = 20) -> list[dict[str, Any]]:
+    """Search for symbols by name or ticker.
+
+    Returns a list of {symbol, exchange, description, type, ...} dicts.
+    """
+    try:
+        from tradingview_screener import Query, col
+    except ImportError as e:
+        raise RuntimeError(
+            "tradingview-screener is not installed. `pip install tradingview-screener`"
+        ) from e
+
+    # tradingview-screener's `.like()` does substring matching directly
+    # (no SQL `%` wildcards needed) and is case-sensitive.
+    # We OR-match the uppercase ticker form against `name` and the
+    # title-cased / original form against `description`.
+    q_upper = query.upper()
+    q_title = query.title() if query.islower() else query
+
+    q = (
+        Query()
+        .select("name", "description", "type", "exchange", "country")
+        .where(
+            col("name").like(q_upper)
+            | col("description").like(q_title)
+            | col("description").like(query)
+        )
+        .limit(limit)
+    )
+    _, df = q.get_scanner_data()
+    if df is not None and not df.empty:
+        return df.to_dict(orient="records")
+    return _verified_taiwan_matches(query, limit)
+
+
+def screener(
+    market: str = "america",
+    columns: Optional[Iterable[str]] = None,
+    filters: Optional[list[tuple[str, str, Any]]] = None,
+    order_by: Optional[tuple[str, bool]] = None,  # (col, ascending)
+    limit: int = 50,
+) -> pd.DataFrame:
+    """Run a TradingView screener query.
+
+    Args:
+        market: "america", "crypto", "forex", "futures", "indonesia", ...
+        columns: which fields to fetch (e.g. ["name", "close", "RSI", "volume"])
+        filters: list of (column, op, value) tuples. Ops: "=", ">", "<", ">=", "<=", "!=", "in_range", "above_pct", ...
+        order_by: (column, ascending?)
+        limit: max rows
+    """
+    try:
+        from tradingview_screener import Query, col
+    except ImportError as e:
+        raise RuntimeError(
+            "tradingview-screener is not installed. `pip install tradingview-screener`"
+        ) from e
+
+    cols = list(columns) if columns else ["name", "close", "volume", "RSI", "change"]
+    q = Query().set_markets(market).select(*cols)
+
+    if filters:
+        for c, op, v in filters:
+            expr = col(c)
+            if op == ">":
+                q = q.where(expr > v)
+            elif op == "<":
+                q = q.where(expr < v)
+            elif op == ">=":
+                q = q.where(expr >= v)
+            elif op == "<=":
+                q = q.where(expr <= v)
+            elif op == "=" or op == "==":
+                q = q.where(expr == v)
+            elif op == "!=":
+                q = q.where(expr != v)
+            else:
+                raise ValueError(f"Unsupported op '{op}'. Use one of >, <, >=, <=, =, !=")
+
+    if order_by:
+        order_col, ascending = order_by
+        q = q.order_by(order_col, ascending=ascending)
+
+    q = q.limit(limit)
+    _, df = q.get_scanner_data()
+    return df if df is not None else pd.DataFrame()
+
+
+# Known exchanges by asset class. Used to pick the right scanner market.
+_CRYPTO_EXCHANGES = {
+    "BINANCE", "COINBASE", "KRAKEN", "BITSTAMP", "BITFINEX", "BYBIT",
+    "OKX", "KUCOIN", "HUOBI", "GEMINI", "BITTREX", "POLONIEX",
+    "CRYPTO", "CRYPTOCAP", "UNISWAP", "UNISWAP3ETH",
+}
+_FOREX_EXCHANGES = {"FX", "FX_IDC", "OANDA", "FOREXCOM", "SAXO", "PEPPERSTONE"}
+_FUTURES_EXCHANGES = {"CME", "CME_MINI", "COMEX", "NYMEX", "CBOT", "ICE", "EUREX"}
+
+
+def _market_for_symbol(symbol: str) -> str:
+    """Guess the right scanner market from a TV symbol like 'EXCHANGE:TICKER'."""
+    if ":" not in symbol:
+        return "america"
+    exchange = symbol.split(":", 1)[0].upper()
+    if exchange in _CRYPTO_EXCHANGES:
+        return "crypto"
+    if exchange in _FOREX_EXCHANGES:
+        return "forex"
+    if exchange in _FUTURES_EXCHANGES:
+        return "futures"
+    return "america"
+
+
+def technical_rating(symbol: str, interval: str = "1D") -> dict[str, Any]:
+    """Get TradingView's "Strong Buy / Buy / Neutral / Sell / Strong Sell" rating.
+
+    Uses `tradingview-screener` to fetch the per-symbol Recommend.All field.
+
+    Note: TradingView's scanner API currently returns reliable data only for
+    equity markets (us, world stock exchanges). Crypto/forex/futures scanners
+    are present in the library but the upstream endpoints have been returning
+    empty results since early 2026. We attempt the right market based on the
+    exchange prefix and surface a clear error if no data comes back.
+    """
+    try:
+        from tradingview_screener import Query, col
+    except ImportError as e:
+        raise RuntimeError(
+            "tradingview-screener is not installed. `pip install tradingview-screener`"
+        ) from e
+
+    bare = symbol.split(":", 1)[-1]
+    market = _market_for_symbol(symbol)
+
+    q = (
+        Query()
+        .set_markets(market)
+        .select(
+            "name",
+            "Recommend.All",
+            "Recommend.MA",
+            "Recommend.Other",
+            "RSI",
+            "close",
+        )
+        .where(col("name") == bare)
+        .limit(1)
+    )
+    try:
+        _, df = q.get_scanner_data()
+    except Exception as e:
+        return {
+            "symbol": symbol,
+            "rating": None,
+            "market_tried": market,
+            "error": f"scanner query failed: {e}",
+        }
+
+    if df is None or df.empty:
+        msg = f"not found on '{market}' market"
+        if market != "america":
+            msg += (
+                " (TradingView's non-equity scanner endpoints are currently"
+                " returning empty results)"
+            )
+        return {
+            "symbol": symbol,
+            "rating": None,
+            "market_tried": market,
+            "error": msg,
+        }
+
+    row = df.iloc[0].to_dict()
+    score = row.get("Recommend.All")
+
+    def label(s: float | None) -> str:
+        if s is None:
+            return "Unknown"
+        if s >= 0.5:
+            return "Strong Buy"
+        if s >= 0.1:
+            return "Buy"
+        if s > -0.1:
+            return "Neutral"
+        if s > -0.5:
+            return "Sell"
+        return "Strong Sell"
+
+    return {
+        "symbol": symbol,
+        "interval": interval,
+        "market": market,
+        "rating": label(score),
+        "score": score,
+        "rsi": row.get("RSI"),
+        "close": row.get("close"),
+        "ma_score": row.get("Recommend.MA"),
+        "oscillator_score": row.get("Recommend.Other"),
+    }