@kuandotdev/indicator 0.1.1 → 0.1.3

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

@@ -0,0 +1,92 @@
+"""`training-view browser ...` subcommands."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+app = typer.Typer(no_args_is_help=True, help="Browser automation (Playwright) for TradingView.")
+console = Console()
+
+
+@app.command("session-check")
+def session_check() -> None:
+    """Verify the saved browser profile / session cookie is still valid."""
+    from ..browser.automation import session_check as do_check
+
+    r = do_check()
+    ok = "✅" if r["signed_in"] else "❌"
+
+    method_label = {
+        "env":             "env var (TV_SESSIONID in .env)",
+        "browser_profile": "browser profile (saved by `make login`)",
+        "both":            "env var + browser profile (both)",
+        "none":            "none",
+    }[r["auth_method"]]
+
+    console.print(f"  {ok} signed_in:           [bold]{r['signed_in']}[/bold]")
+    console.print(f"     auth method:         {method_label}")
+    console.print(
+        f"     via .env cookie:     {'✓' if r['via_env_cookie'] else '✗'}"
+        f"   (TV_SESSIONID set in .env)"
+    )
+    console.print(
+        f"     via browser profile: {'✓' if r['via_browser_profile'] else '✗'}"
+        f"   (sessionid cookie persisted in Playwright profile)"
+    )
+    console.print(f"     profile_dir:         {r['profile_dir']}")
+
+    if not r["signed_in"]:
+        console.print(
+            "\n  [yellow]Hint:[/yellow] run [bold]make login[/bold] for an interactive sign-in,"
+            " or paste a fresh sessionid into .env."
+        )
+
+
+@app.command()
+def login(
+    timeout: int = typer.Option(300, "--timeout", help="Seconds to wait for manual login")
+) -> None:
+    """Open a visible browser so you can log in manually. Profile is saved."""
+    from ..browser.automation import interactive_login
+
+    r = interactive_login(timeout_seconds=timeout)
+    if r["signed_in"]:
+        console.print(f"[green]✅ {r['message']}[/green]")
+    else:
+        console.print(f"[red]❌ {r['message']}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def push(
+    script: Path = typer.Argument(..., exists=True, help="Path to .pine file"),
+    apply: Optional[str] = typer.Option(
+        None, "--apply", help="Symbol to apply chart to, e.g. NASDAQ:AAPL"
+    ),
+    screenshot: bool = typer.Option(False, "--screenshot", "-s", help="Save a chart screenshot"),
+    name: Optional[str] = typer.Option(None, "--name", help="Script name in TradingView"),
+) -> None:
+    """Paste a .pine file into TV Pine Editor, save, optionally apply + screenshot."""
+    from ..browser.automation import push_script
+
+    r = push_script(script, apply_to=apply, screenshot=screenshot, script_name=name)
+    console.print_json(json.dumps(r, default=str))
+    if r["errors"]:
+        raise typer.Exit(1)
+
+
+@app.command()
+def screenshot(
+    symbol: Optional[str] = typer.Option(None, "--symbol", "-s"),
+    layout: Optional[str] = typer.Option(None, "--layout", help="Layout URL"),
+    out: Optional[Path] = typer.Option(None, "--out", "-o"),
+) -> None:
+    """Open a chart and save a screenshot."""
+    from ..browser.automation import screenshot_chart
+
+    path = screenshot_chart(symbol=symbol, layout_url=layout, out_path=out)
+    console.print(f"[green]Saved:[/green] {path}")

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

@@ -0,0 +1,178 @@
+"""`training-view data ...` subcommands."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer(no_args_is_help=True, help="Pull OHLCV, search symbols, run screener.")
+console = Console()
+
+
+@app.command()
+def ohlcv(
+    symbol: str = typer.Argument(..., help="Symbol, e.g. NASDAQ:AAPL or AAPL"),
+    interval: str = typer.Option("1D", "--interval", "-i", help="1, 5, 15, 60, 240, 1D, 1W, 1M"),
+    bars: int = typer.Option(500, "--bars", "-n", help="Number of bars to fetch"),
+    exchange: Optional[str] = typer.Option(None, "--exchange", "-e"),
+    csv: Optional[Path] = typer.Option(None, "--csv", help="Write to CSV instead of printing"),
+    tail: int = typer.Option(10, "--tail", help="Rows to print when not writing CSV"),
+) -> None:
+    """Fetch OHLCV candles for SYMBOL."""
+    from ..data.client import get_ohlcv
+
+    try:
+        df = get_ohlcv(symbol, interval=interval, n_bars=bars, exchange=exchange)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    if df.empty:
+        console.print(f"[yellow]No data returned for {symbol}[/yellow]")
+        raise typer.Exit(2)
+
+    if csv:
+        csv.parent.mkdir(parents=True, exist_ok=True)
+        df.to_csv(csv)
+        console.print(f"[green]Wrote {len(df)} rows → {csv}[/green]")
+        return
+
+    table = Table(title=f"{symbol} · {interval} · last {min(tail, len(df))} of {len(df)} bars")
+    table.add_column("time")
+    for c in df.columns:
+        table.add_column(c, justify="right")
+    for ts, row in df.tail(tail).iterrows():
+        table.add_row(str(ts), *[f"{v:.4f}" if isinstance(v, float) else str(v) for v in row])
+    console.print(table)
+
+
+@app.command()
+def search(
+    query: str = typer.Argument(..., help="Ticker or name fragment"),
+    limit: int = typer.Option(20, "--limit", "-n"),
+) -> None:
+    """Search symbols by name/ticker."""
+    from ..data.screener import search_symbol
+
+    try:
+        results = search_symbol(query, limit=limit)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    if not results:
+        console.print(f"[yellow]No matches for '{query}'[/yellow]")
+        return
+
+    table = Table(title=f"Search: {query}")
+    for k in results[0].keys():
+        table.add_column(str(k))
+    for row in results:
+        table.add_row(*[str(row.get(k, "")) for k in results[0].keys()])
+    console.print(table)
+
+
+@app.command()
+def screener(
+    market: str = typer.Option("america", "--market", "-m"),
+    filter_: list[str] = typer.Option(
+        [], "--filter", "-f",
+        help="Filter expression COL OP VAL (e.g. 'RSI < 30'). Repeatable.",
+    ),
+    columns: list[str] = typer.Option(
+        [], "--col", "-c",
+        help="Columns to include. Repeatable. Default: name, close, RSI, volume, change",
+    ),
+    order_by: Optional[str] = typer.Option(
+        None, "--order-by", help="Column to sort by (prefix '-' for descending)"
+    ),
+    limit: int = typer.Option(50, "--limit", "-n"),
+) -> None:
+    """Run a TradingView screener.
+
+    Example:
+
+      training-view data screener -m america -f "RSI < 30" -f "volume > 1000000" -c name -c close -c RSI
+    """
+    from ..data.screener import screener as run_screener
+
+    # Parse filters
+    parsed: list[tuple[str, str, object]] = []
+    for f in filter_:
+        parts = f.split(maxsplit=2)
+        if len(parts) != 3:
+            console.print(f"[red]Bad filter:[/red] '{f}' — expected 'COL OP VAL'")
+            raise typer.Exit(1)
+        col, op, val = parts
+        try:
+            v: object = float(val)
+        except ValueError:
+            v = val
+        parsed.append((col, op, v))
+
+    sort = None
+    if order_by:
+        ascending = not order_by.startswith("-")
+        sort = (order_by.lstrip("-"), ascending)
+
+    try:
+        df = run_screener(
+            market=market,
+            columns=columns or None,
+            filters=parsed or None,
+            order_by=sort,
+            limit=limit,
+        )
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    if df.empty:
+        console.print("[yellow]No rows.[/yellow]")
+        return
+
+    table = Table(title=f"Screener · {market} · {len(df)} rows")
+    for c in df.columns:
+        table.add_column(str(c))
+    for _, row in df.iterrows():
+        table.add_row(*[f"{v:.4f}" if isinstance(v, float) else str(v) for v in row])
+    console.print(table)
+
+
+@app.command()
+def rating(
+    symbol: str = typer.Argument(..., help="Symbol, e.g. AAPL or NASDAQ:AAPL"),
+    interval: str = typer.Option("1D", "--interval", "-i"),
+) -> None:
+    """Get TradingView's Strong Buy/Buy/Neutral/Sell/Strong Sell rating."""
+    from ..data.screener import technical_rating
+
+    try:
+        r = technical_rating(symbol, interval=interval)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    if r.get("rating") is None:
+        console.print(f"[yellow]⚠  {r.get('error', 'no data')}[/yellow]")
+        if r.get("market_tried"):
+            console.print(f"[dim]   market tried: {r['market_tried']}[/dim]")
+        return
+
+    colors = {
+        "Strong Buy": "bold green",
+        "Buy": "green",
+        "Neutral": "yellow",
+        "Sell": "red",
+        "Strong Sell": "bold red",
+    }
+    c = colors.get(r["rating"], "white")
+    console.print(f"\n  [bold]{r['symbol']}[/bold]  →  [{c}]{r['rating']}[/{c}]")
+    console.print(f"  score:     {r.get('score')}")
+    console.print(f"  rsi:       {r.get('rsi')}")
+    console.print(f"  close:     {r.get('close')}")
+    console.print(f"  MA score:  {r.get('ma_score')}")
+    console.print(f"  Osc score: {r.get('oscillator_score')}\n")

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

@@ -0,0 +1,56 @@
+"""`training-view` — TradingView integration toolkit CLI.
+
+Run `training-view --help` for all commands.
+"""
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from .data_cmds import app as data_app
+from .browser_cmds import app as browser_app
+from .pine_cmds import app as pine_app
+from .model_cmds import app as model_app
+
+app = typer.Typer(
+    name="training-view",
+    help="TradingView toolkit: data, browser automation, and PineScript scaffolding.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console()
+
+app.add_typer(data_app, name="data", help="Pull OHLCV, search symbols, run screener.")
+app.add_typer(browser_app, name="browser", help="Push Pine scripts, screenshot charts.")
+app.add_typer(pine_app, name="pine", help="Scaffold Pine indicators / strategies.")
+app.add_typer(model_app, name="model", help="Fetch server-side stock/ETF/index model forecasts.")
+
+
+@app.command()
+def version() -> None:
+    """Print version."""
+    from importlib.metadata import version as v
+
+    try:
+        console.print(f"TradingView toolkit [bold]{v('tv-indicator')}[/bold]")
+    except Exception:
+        console.print("TradingView toolkit (dev)")
+
+
+@app.command()
+def status() -> None:
+    """Show config + auth status."""
+    from ..config import settings
+
+    console.print("[bold]TradingView integration toolkit[/bold]")
+    console.print(f"  Session cookie set:    {'✅' if settings.has_session else '❌'}")
+    console.print(f"  Username:              {settings.tv_username or '—'}")
+    console.print(f"  Browser profile:       {settings.browser_profile}")
+    console.print(f"  Headless:              {settings.browser_headless}")
+    console.print(f"  Default chart URL:     {settings.default_chart_url or '—'}")
+    console.print(f"  Screenshot dir:        {settings.screenshot_dir}")
+    console.print(f"  Scripts dir:           {settings.scripts_dir}")
+
+
+if __name__ == "__main__":
+    app()

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

@@ -0,0 +1,255 @@
+"""`training-view model ...` subcommands for server-side stock forecast integration."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..model.forecast import dumps_json, forecast_for_symbol, model_status, setup_model_env
+
+app = typer.Typer(no_args_is_help=True, help="Server-side stock/ETF/index forecast API.")
+console = Console()
+
+
+@app.command("status")
+def status(
+    repo: Optional[Path] = typer.Option(
+        None,
+        "--repo",
+        help="Deprecated; ignored because the model now runs server-side.",
+    ),
+    csv_path: Optional[Path] = typer.Option(
+        None,
+        "--csv",
+        help="Deprecated; ignored because forecasts now come from the API.",
+    ),
+    conda_env: Optional[str] = typer.Option(
+        None,
+        "--conda-env",
+        help="Deprecated; ignored because no local ML runtime is used.",
+    ),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="Forecast endpoint. Defaults to TV_MODEL_API_URL or TV_MODEL_API_BASE_URL + /forecast.",
+    ),
+    status_url: Optional[str] = typer.Option(
+        None,
+        "--status-url",
+        help="Optional API health endpoint. Defaults to TV_MODEL_API_STATUS_URL.",
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Print raw JSON payload."),
+) -> None:
+    """Show server-side model API configuration/status."""
+    payload = model_status(
+        repo=repo,
+        csv_path=csv_path,
+        conda_env=conda_env or None,
+        api_url=api_url,
+        status_url=status_url,
+    )
+    if json_output:
+        print(dumps_json(payload))
+        return
+
+    console.print("[bold]Server-side stock/ETF/index model forecast API[/bold]")
+    console.print(f"  forecast API:    {_mark(payload['model_api_configured'])} {payload.get('model_api_url') or 'not configured'}")
+    console.print(f"  status API:      {_status_mark(payload.get('model_api_reachable'))} {payload.get('model_api_status_url') or 'not configured'}")
+    if payload.get("model_api_error"):
+        console.print(f"  API note:        [yellow]{payload['model_api_error']}[/yellow]")
+    console.print(f"  temp dir:        {_mark(payload['temp_dir_exists'])} {payload['temp_dir']}")
+    console.print("  auth:            " + ("Bearer token set" if _api_token_set() else "no token"))
+    console.print("  commands:")
+    for value in payload["commands"].values():
+        console.print(f"    {value}")
+    if payload.get("next_actions"):
+        console.print("  next actions:")
+        for action in payload["next_actions"]:
+            console.print(f"    - {action}")
+
+
+@app.command("setup")
+def setup(
+    repo: Optional[Path] = typer.Option(
+        None,
+        "--repo",
+        help="Deprecated; ignored because the model now runs server-side.",
+    ),
+    conda_env: Optional[str] = typer.Option(
+        None,
+        "--conda-env",
+        help="Deprecated; ignored because no local ML runtime is used.",
+    ),
+    no_extra_deps: bool = typer.Option(
+        False,
+        "--no-extra-deps",
+        help="Deprecated; no local model dependencies are installed.",
+    ),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="Forecast endpoint. Defaults to TV_MODEL_API_URL or TV_MODEL_API_BASE_URL + /forecast.",
+    ),
+    status_url: Optional[str] = typer.Option(
+        None,
+        "--status-url",
+        help="Optional API health endpoint. Defaults to TV_MODEL_API_STATUS_URL.",
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Print raw JSON payload."),
+) -> None:
+    """Validate server-side model API configuration."""
+    payload = setup_model_env(
+        repo=repo,
+        conda_env=conda_env,
+        install_extra_deps=not no_extra_deps,
+        api_url=api_url,
+        status_url=status_url,
+    )
+    if json_output:
+        print(dumps_json(payload))
+        return
+
+    ok = "✓" if payload["ok"] else "✗"
+    console.print(f"[bold]Model API setup[/bold] {ok}")
+    if payload["stdout"]:
+        console.print(payload["stdout"])
+    if payload["stderr"]:
+        console.print(f"[yellow]{payload['stderr']}[/yellow]")
+    if not payload["ok"]:
+        raise typer.Exit(1)
+
+
+@app.command("forecast")
+def forecast(
+    symbol: str = typer.Argument(..., help="Ticker or TradingView symbol, e.g. TSLA or NASDAQ:TSLA"),
+    repo: Optional[Path] = typer.Option(
+        None,
+        "--repo",
+        help="Deprecated; ignored because forecasts now come from the API.",
+    ),
+    csv_path: Optional[Path] = typer.Option(
+        None,
+        "--csv",
+        help="Deprecated; ignored because forecasts now come from the API.",
+    ),
+    refresh: bool = typer.Option(
+        False,
+        "--refresh",
+        help="Ask the server-side model API to refresh/recompute before returning a forecast.",
+    ),
+    conda_env: Optional[str] = typer.Option(
+        None,
+        "--conda-env",
+        help="Deprecated; ignored because no local ML runtime is used.",
+    ),
+    period: str = typer.Option("10y", "--period", help="Historical period hint sent to the API."),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="Forecast endpoint. Defaults to TV_MODEL_API_URL or TV_MODEL_API_BASE_URL + /forecast.",
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Print raw JSON payload."),
+) -> None:
+    """Fetch the xs_range 20-day model forecast for a ticker from the API.
+
+    Crypto, forex, and futures symbols are reported as not applicable without an
+    API request.
+    """
+    payload = forecast_for_symbol(
+        symbol,
+        repo=repo,
+        csv_path=csv_path,
+        refresh=refresh,
+        conda_env=conda_env or None,
+        period=period,
+        api_url=api_url,
+    )
+
+    if json_output:
+        # Plain stdout so agents can parse JSON without Rich line wrapping.
+        print(dumps_json(payload))
+    else:
+        _print_human(payload)
+
+    # Forecast unavailability is a handled analysis state. Keep exit code 0 so
+    # agents can continue with TradingView/news/fundamentals and inspect
+    # payload["ok"] / payload["error"] instead of aborting the full report.
+
+
+def _mark(ok: bool) -> str:
+    return "✓" if ok else "✗"
+
+
+def _status_mark(value: object) -> str:
+    if value is True:
+        return "✓"
+    if value is False:
+        return "✗"
+    return "-"
+
+
+def _api_token_set() -> bool:
+    import os
+
+    return bool(os.getenv("TV_MODEL_API_KEY") or os.getenv("TV_MODEL_API_TOKEN"))
+
+
+def _print_human(payload: dict) -> None:
+    row = payload.get("row")
+    console.print(f"[bold]Model ticker:[/bold] {payload['model_ticker']}  covered={payload['covered']}")
+    if not payload.get("model_applicable", True):
+        console.print(f"[bold]Asset class:[/bold] {payload.get('asset_class')}")
+        console.print(f"[yellow]Model forecast not applicable:[/yellow] {payload.get('unsupported_reason')}")
+        console.print("[yellow]No API request was made.[/yellow]")
+        return
+    console.print(f"[bold]Forecast API:[/bold] {payload.get('model_api_url') or 'not configured'}")
+    if payload.get("refresh_requested"):
+        console.print("[bold]Refresh requested:[/bold] yes")
+
+    if not row:
+        console.print(f"[yellow]Model forecast unavailable:[/yellow] {payload.get('error')}")
+        return
+
+    table = Table(title="20-day model forecast")
+    table.add_column("Field")
+    table.add_column("Value", justify="right")
+    fields = [
+        "ticker",
+        "class",
+        "position",
+        "rank",
+        "close",
+        "low_20d",
+        "high_20d",
+        "fair_value",
+        "value_gap",
+        "signal",
+        "mean_iou",
+        "iou60",
+        "dir_win",
+        "pred_low_pct",
+        "pred_high_pct",
+        "pred_mid_pct",
+        "range_width_pct",
+        "direction",
+        "directional_win_rate",
+        "range_overlap_rate",
+        "close_in_range_rate",
+        "range_coverage_rate",
+    ]
+    for field in fields:
+        if field in row and row[field] is not None:
+            table.add_row(field, _fmt(row[field]))
+    console.print(table)
+    if payload.get("model_output"):
+        console.print("[bold]model_output:[/bold]")
+        console.print(dumps_json(payload["model_output"]))
+
+
+def _fmt(value: object) -> str:
+    if isinstance(value, float):
+        return f"{value:.4f}"
+    return str(value)