synth-ai 0.2.14__py3-none-any.whl → 0.4.4__py3-none-any.whl

synth_ai/cli/balance.py

@@ -1,216 +0,0 @@
-#!/usr/bin/env python3
-"""
-CLI: check remaining credit balance from Synth backend.
-"""
-
-from __future__ import annotations
-
-import importlib
-import os
-from collections.abc import Callable
-from typing import Any, cast
-
-import click
-import requests
-from requests import Response
-from rich import box
-from rich.console import Console
-from rich.table import Table
-
-
-def _load_base_url_module() -> tuple[str, Callable[[], tuple[str, str]]]:
-    try:
-        module = cast(Any, importlib.import_module("synth_ai.config.base_url"))
-        default = cast(str, module.PROD_BASE_URL_DEFAULT)
-        getter = cast(Callable[[], tuple[str, str]], module.get_backend_from_env)
-        return str(default), getter
-    except Exception:
-        return "https://agent-learning.onrender.com", lambda: ("https://agent-learning.onrender.com", "")
-
-
-PROD_BASE_URL_DEFAULT, _get_backend_from_env = _load_base_url_module()
-PROD_BACKEND_BASE = f"{PROD_BASE_URL_DEFAULT.rstrip('/')}/api/v1"
-
-
-def _get_default_base_url() -> str:
-    # Prefer explicit backend variables; else default to prod backend
-    for var in ("SYNTH_BACKEND_BASE_URL", "BACKEND_BASE_URL", "SYNTH_BASE_URL"):
-        val = os.getenv(var)
-        if val:
-            return val
-    base, _ = _get_backend_from_env()
-    base = base.rstrip("/")
-    if base.endswith("/api"):
-        base = base[: -len("/api")]
-    return f"{base}/api/v1"
-
-
-def _ensure_api_v1_prefix(base_url: str) -> str:
-    """Ensure the base URL includes the /api/v1 prefix.
-
-    Accepts either a full prefix (http://host:port/api/v1) or a root
-    service URL (http://host:port). If no '/api' segment is present, append
-    '/api/v1'.
-    """
-    b = base_url.rstrip("/")
-    if b.endswith("/api") or b.endswith("/api/v1") or "/api/" in b:
-        return b
-    return b + "/api/v1"
-
-
-def _resolve_api_key(explicit_key: str | None) -> tuple[str | None, str | None]:
-    if explicit_key:
-        return explicit_key, "--api-key"
-    # Try multiple env vars commonly used in this repo
-    for var in ("SYNTH_BACKEND_API_KEY", "SYNTH_API_KEY", "DEFAULT_DEV_API_KEY"):
-        val = os.getenv(var)
-        if val:
-            return val, var
-    return None, None
-
-
-def _auth_headers(api_key: str | None) -> dict[str, str]:
-    key, _ = _resolve_api_key(api_key)
-    if not key:
-        return {}
-    return {"Authorization": f"Bearer {key}"}
-
-
-def register(cli):
-    @cli.command()
-    @click.option(
-        "--base-url",
-        default=_get_default_base_url,
-        show_default=True,
-        help="Synth backend base URL (prefix like http://host:port/api/v1)",
-    )
-    @click.option(
-        "--api-key",
-        envvar="SYNTH_API_KEY",
-        help="API key for the Synth backend (or set SYNTH_API_KEY)",
-    )
-    @click.option(
-        "--usage/--no-usage",
-        default=False,
-        help="Also fetch recent usage summary",
-    )
-    def balance(base_url: str, api_key: str | None, usage: bool):
-        """Show your remaining credit balance from the Synth backend."""
-        console = Console()
-
-        key_val, key_src = _resolve_api_key(api_key)
-        if not key_val:
-            console.print("[red]Missing API key.[/red] Set via --api-key or SYNTH_API_KEY env var.")
-            return
-
-        base = _ensure_api_v1_prefix(base_url)
-
-        # No special-casing for modal.run domains; honor the provided base URL
-
-        try:
-            resp: Response = requests.get(
-                f"{base}/balance/current",
-                headers=_auth_headers(api_key),
-                timeout=10,
-            )
-            resp.raise_for_status()
-            data = resp.json()
-            cents = int(data.get("balance_cents", 0))
-            dollars = float(data.get("balance_dollars", cents / 100.0))
-            console.print(f"Balance: [bold]${dollars:,.2f}[/bold]")
-
-            # Try to print compact spend summary for 24h and 7d
-            try:
-                u: Response = requests.get(
-                    f"{base}/balance/usage/windows",
-                    params={"hours": "24,168"},
-                    headers=_auth_headers(api_key),
-                    timeout=10,
-                )
-                if u.ok:
-                    uj = u.json()
-                    rows = uj.get("windows", [])
-                    windows = {
-                        int(r.get("window_hours")): r
-                        for r in rows
-                        if isinstance(r.get("window_hours"), int)
-                    }
-
-                    def _usd(c):
-                        try:
-                            return f"${(int(c) / 100):,.2f}"
-                        except Exception:
-                            return "$0.00"
-
-                    if 24 in windows or 168 in windows:
-                        t = Table(
-                            title="Spend (Tokens vs GPU)", box=box.SIMPLE, header_style="bold"
-                        )
-                        t.add_column("Window")
-                        t.add_column("Tokens", justify="right")
-                        t.add_column("GPU", justify="right")
-                        t.add_column("Total", justify="right")
-                        for h, label in ((24, "24h"), (168, "7d")):
-                            if h in windows:
-                                w = windows[h]
-                                t.add_row(
-                                    label,
-                                    _usd(w.get("token_spend_cents", 0)),
-                                    _usd(w.get("gpu_spend_cents", 0)),
-                                    _usd(w.get("total_spend_cents", 0)),
-                                )
-                        console.print(t)
-                elif usage:
-                    # Fallback to older summary if requested explicitly
-                    u2: Response = requests.get(
-                        f"{base}/balance/usage",
-                        headers=_auth_headers(api_key),
-                        timeout=10,
-                    )
-                    if u2.ok:
-                        uj = u2.json()
-                        cm = uj.get("current_month", {})
-                        l30 = uj.get("last_30_days", {})
-                        t = Table(title="Usage Summary", box=box.SIMPLE, header_style="bold")
-                        t.add_column("Window")
-                        t.add_column("Token Spend", justify="right")
-                        t.add_column("GPU Spend", justify="right")
-                        t.add_column("Total", justify="right")
-                        t.add_row(
-                            "Current Month",
-                            f"${(cm.get('token_spend_cents', 0) / 100):,.2f}",
-                            f"${(cm.get('gpu_spend_cents', 0) / 100):,.2f}",
-                            f"${(cm.get('total_spend_cents', 0) / 100):,.2f}",
-                        )
-                        t.add_row(
-                            "Last 30 days",
-                            f"${(l30.get('token_spend_cents', 0) / 100):,.2f}",
-                            f"${(l30.get('gpu_spend_cents', 0) / 100):,.2f}",
-                            f"${(l30.get('total_spend_cents', 0) / 100):,.2f}",
-                        )
-                        console.print(t)
-            except Exception:
-                # Silent failure on usage summary
-                pass
-
-        except requests.HTTPError as e:
-            try:
-                detail = e.response.json().get("detail") if e.response else None
-            except Exception:
-                detail = None
-            if e.response is not None and e.response.status_code == 401:
-                key_dbg, key_src = _resolve_api_key(api_key)
-                shown = (key_dbg[:6] + "…" + key_dbg[-4:]) if key_dbg else "<none>"
-                console.print(
-                    "[red]Unauthorized (401).[/red] The API key was not accepted by the backend."
-                )
-                console.print(
-                    f"- Using base URL: {base}\n- API key (masked): {shown}\n- Key source: {key_src or '<none>'}\n- Ensure this key exists in the backend DB (table api_keys) and is active."
-                )
-                console.print(
-                    "If running locally, you can seed a dev key by setting ENVIRONMENT=dev and ensuring the DB has no API keys (auto-seed path), or create one via your admin path."
-                )
-            else:
-                console.print(f"[red]HTTP error:[/red] {e} {detail or ''}")
-        except Exception as e:
-            console.print(f"[red]Error:[/red] {e}")

synth_ai/cli/calc.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-"""
-CLI: basic calculator for quick math in terminal.
-Safe evaluation of arithmetic expressions.
-"""
-
-import ast
-import operator
-from collections.abc import Callable
-
-import click
-from rich.console import Console
-
-# Supported operators
-_BINARY_OPS: dict[type[ast.AST], Callable[[float, float], float]] = {
-    ast.Add: operator.add,
-    ast.Sub: operator.sub,
-    ast.Mult: operator.mul,
-    ast.Div: operator.truediv,
-    ast.FloorDiv: operator.floordiv,
-    ast.Mod: operator.mod,
-    ast.Pow: operator.pow,
-}
-
-_UNARY_OPS: dict[type[ast.AST], Callable[[float], float]] = {
-    ast.USub: operator.neg,
-    ast.UAdd: operator.pos,
-}
-
-
-def _safe_eval(expr: str) -> float:
-    node = ast.parse(expr, mode="eval")
-
-    def _eval(n: ast.AST) -> float:
-        if isinstance(n, ast.Expression):
-            return _eval(n.body)
-        if isinstance(n, ast.Constant):
-            if isinstance(n.value, int | float):
-                return float(n.value)
-            raise ValueError("Only numeric constants are allowed")
-        num_node = getattr(ast, "Num", None)
-        if num_node is not None and isinstance(n, num_node):  # pragma: no cover
-            numeric_value = getattr(n, "n", None)
-            if isinstance(numeric_value, int | float):
-                return float(numeric_value)
-            raise ValueError("Only numeric constants are allowed")
-        if isinstance(n, ast.BinOp):
-            op_type = type(n.op)
-            func = _BINARY_OPS.get(op_type)
-            if func:
-                return func(_eval(n.left), _eval(n.right))
-        if isinstance(n, ast.UnaryOp):
-            op_type = type(n.op)
-            func = _UNARY_OPS.get(op_type)
-            if func:
-                return func(_eval(n.operand))
-        if isinstance(n, ast.Expr):
-            return _eval(n.value)
-        raise ValueError("Unsupported expression")
-
-    result = _eval(node)
-    return float(result)
-
-
-def register(cli):
-    @cli.command(name="calc")
-    @click.argument("expr", nargs=-1)
-    def calc(expr: tuple[str, ...]):
-        """Evaluate a basic math expression, e.g., "(12_345 + 6789) / 100".
-
-        Supports + - * / // % ** and parentheses. No variables or functions.
-        """
-        console = Console()
-        expression = " ".join(expr).strip()
-        if not expression:
-            console.print("[dim]Usage:[/dim] synth-ai calc '2*(3+4)' or: uvx . calc 2 + 2")
-            return
-        try:
-            # Allow underscores in numbers for readability
-            expression = expression.replace("_", "")
-            result = _safe_eval(expression)
-            console.print(f"= [bold]{result}[/bold]")
-        except Exception as e:
-            console.print(f"[red]Error:[/red] {e}")

synth_ai/cli/demo.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-"""
-CLI: interactive launcher for example demos and RL demo helpers.
-
-- `synth-ai demo` (no subcommand) -> initialize RL demo files into ./synth_demo/
-- `synth-ai demo deploy|configure|run` -> invoke RL demo helpers directly.
-"""
-
-from __future__ import annotations
-
-import importlib
-import os
-import subprocess
-from pathlib import Path
-from typing import Any, cast
-
-import click
-from click.exceptions import Exit
-
-demo_commands = cast(
-    Any, importlib.import_module("synth_ai.demos.core.cli")
-)
-
-
-def _find_demo_scripts(root: Path) -> list[Path]:
-    if not root.exists():
-        return []
-    return sorted([p for p in root.rglob("run_demo.sh") if p.is_file()])
-
-
-def _run_demo_command(func, *args, **kwargs) -> None:
-    """Invoke a demo command and exit via Click on non-zero status codes."""
-
-    try:
-        result = func(*args, **kwargs)
-    except SystemExit as exc:  # pragma: no cover - defensive
-        raise Exit(exc.code or 1) from exc
-
-    if result is None:
-        return
-
-    try:
-        code = int(result)
-    except (TypeError, ValueError):
-        return
-    if code != 0:
-        raise Exit(code)
-
-
-def register(cli):
-    @cli.group("demo", invoke_without_command=True)
-    @click.option(
-        "--force", is_flag=True, help="Overwrite existing files in CWD when initializing demo"
-    )
-    @click.option("--list", "list_only", is_flag=True, help="List available legacy demos and exit")
-    @click.option("-f", "filter_term", default="", help="Filter legacy demos by substring")
-    @click.pass_context
-    def demo(ctx: click.Context, force: bool, list_only: bool, filter_term: str):
-        """Demo helpers.
-
-        - Default (no subcommand): initialize RL demo files into ./synth_demo/ (alias of rl_demo init)
-        - Legacy mode: with --list, find and run examples/*/run_demo.sh
-        - New RL demo subcommands: deploy, configure, run
-        """
-        if ctx.invoked_subcommand is not None:
-            return
-
-        # If explicitly asked to list legacy demos, show interactive picker
-        if list_only:
-            repo_root = Path(os.getcwd())
-            examples_dir = repo_root / "examples"
-            demos = _find_demo_scripts(examples_dir)
-            if filter_term:
-                demos = [p for p in demos if filter_term.lower() in str(p).lower()]
-
-            if not demos:
-                click.echo("No run_demo.sh scripts found under examples/.")
-                return
-
-            click.echo("Available demos:")
-            for idx, p in enumerate(demos, start=1):
-                click.echo(f" {idx}. {p.relative_to(repo_root)}")
-            click.echo("")
-
-            def _validate_choice(val: str) -> int:
-                try:
-                    i = int(val)
-                except Exception as err:
-                    raise click.BadParameter("Enter a number from the list") from err
-                if i < 1 or i > len(demos):
-                    raise click.BadParameter(f"Choose a number between 1 and {len(demos)}")
-                return i
-
-            choice = click.prompt("Select a demo to run", value_proc=_validate_choice)
-            script = demos[choice - 1]
-
-            click.echo("")
-            click.echo(f"🚀 Running {script.relative_to(repo_root)}\n")
-
-            try:
-                subprocess.run(["bash", str(script)], check=True)
-            except subprocess.CalledProcessError as e:
-                click.echo(f"❌ Demo exited with non-zero status: {e.returncode}")
-            except KeyboardInterrupt:
-                click.echo("\n🛑 Demo interrupted by user")
-            return
-
-        # Default: initialize RL demo files via new command
-        _run_demo_command(demo_commands.init, force=force)
-
-    # (prepare command removed; configure now prepares baseline TOML)
-
-    # Help pyright understand dynamic Click group attributes
-    _dg = cast(Any, demo)
-
-    @_dg.command("deploy")
-    @click.option("--local", is_flag=True, help="Run local FastAPI instead of Modal deploy")
-    @click.option(
-        "--app",
-        type=click.Path(),
-        default=None,
-        help="Path to Modal app.py for uv run modal deploy",
-    )
-    @click.option("--name", type=str, default="synth-math-demo", help="Modal app name")
-    @click.option(
-        "--script",
-        type=click.Path(),
-        default=None,
-        help="Path to deploy_task_app.sh (optional legacy)",
-    )
-    def demo_deploy(local: bool, app: str | None, name: str, script: str | None):
-        _run_demo_command(
-            demo_commands.deploy,
-            local=local,
-            app=app,
-            name=name,
-            script=script,
-        )
-
-    @_dg.command("configure")
-    def demo_configure():
-        _run_demo_command(demo_commands.run)
-
-    @_dg.command("setup")
-    def demo_setup():
-        _run_demo_command(demo_commands.setup)
-
-    @_dg.command("run")
-    @click.option("--batch-size", type=int, default=None)
-    @click.option("--group-size", type=int, default=None)
-    @click.option("--model", type=str, default=None)
-    @click.option("--timeout", type=int, default=600)
-    def demo_run(batch_size: int | None, group_size: int | None, model: str | None, timeout: int):
-        _run_demo_command(
-            demo_commands.run,
-            batch_size=batch_size,
-            group_size=group_size,
-            model=model,
-            timeout=timeout,
-        )
-
-    @cli.command("setup")
-    def setup_alias():
-        """Perform SDK handshake and write keys to .env."""
-        _run_demo_command(demo_commands.setup)