synth-ai 0.2.10__py3-none-any.whl → 0.2.13.dev1__py3-none-any.whl

synth_ai/api/train/supported_algos.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
+import importlib
 from collections.abc import Mapping
 from dataclasses import dataclass
 
-from synth_ai.api.models.supported import (
-    RL_SUPPORTED_MODELS,
-    SFT_SUPPORTED_MODELS,
-    training_modes_for_model,
-)
+try:
+    _models_module = importlib.import_module("synth_ai.api.models.supported")
+    RL_SUPPORTED_MODELS = _models_module.RL_SUPPORTED_MODELS
+    SFT_SUPPORTED_MODELS = _models_module.SFT_SUPPORTED_MODELS
+    training_modes_for_model = _models_module.training_modes_for_model
+except Exception as exc:  # pragma: no cover - critical dependency
+    raise RuntimeError("Unable to load supported model metadata") from exc
 
 
 @dataclass(frozen=True)

synth_ai/api/train/utils.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import importlib
 import json
 import os
 import re
@@ -13,7 +14,11 @@ from pathlib import Path
 from typing import Any
 
 import requests
-from synth_ai.learning.sft import collect_sft_jsonl_errors
+
+try:
+    collect_sft_jsonl_errors = importlib.import_module("synth_ai.learning.sft").collect_sft_jsonl_errors
+except Exception as exc:  # pragma: no cover - critical dependency
+    raise RuntimeError("Unable to load SFT JSONL helpers") from exc
 
 REPO_ROOT = Path(__file__).resolve().parents[3]
 

synth_ai/cli/__init__.py

@@ -7,6 +7,8 @@ pyproject entry point `synth_ai.cli:cli`.
 
 from __future__ import annotations
 
+import importlib
+
 # Load environment variables from a local .env if present (repo root)
 try:
     from dotenv import find_dotenv, load_dotenv
@@ -89,8 +91,8 @@ try:
 except Exception:
     pass
 try:
-    from synth_ai.api.train import register as _train_register
-
+    _train_module = importlib.import_module("synth_ai.api.train")
+    _train_register = _train_module.register
     _train_register(cli)
 except Exception:
     pass

synth_ai/cli/_storage.py

@@ -0,0 +1,19 @@
+"""Dynamic loader for tracing storage components.
+
+This avoids hard dependencies on the tracing_v3 storage package during import
+time, which keeps CLI modules usable in constrained environments while still
+allowing type checkers to resolve the symbols dynamically.
+"""
+
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+
+def load_storage() -> tuple[Any, Any]:
+    """Return (create_storage, StorageConfig) from tracing_v3.storage."""
+    storage_module = importlib.import_module("synth_ai.tracing_v3.storage")
+    create_storage = storage_module.create_storage
+    storage_config = storage_module.StorageConfig
+    return create_storage, storage_config

synth_ai/cli/balance.py

@@ -5,7 +5,9 @@ CLI: check remaining credit balance from Synth backend.
 
 from __future__ import annotations
 
+import importlib
 import os
+from collections.abc import Callable
 
 import click
 import requests
@@ -14,8 +16,18 @@ from rich import box
 from rich.console import Console
 from rich.table import Table
 
-from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT, get_backend_from_env
 
+def _load_base_url_module() -> tuple[str, Callable[[], tuple[str, str]]]:
+    try:
+        module = importlib.import_module("synth_ai.config.base_url")
+        default = module.PROD_BASE_URL_DEFAULT
+        getter = 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"
 
 
@@ -25,7 +37,7 @@ def _get_default_base_url() -> str:
         val = os.getenv(var)
         if val:
             return val
-    base, _ = get_backend_from_env()
+    base, _ = _get_backend_from_env()
     base = base.rstrip("/")
     if base.endswith("/api"):
         base = base[: -len("/api")]

synth_ai/cli/calc.py

@@ -5,46 +5,61 @@ Safe evaluation of arithmetic expressions.
 """
 
 import ast
-import operator as op
+import operator
+from collections.abc import Callable
 
 import click
 from rich.console import Console
 
 # Supported operators
-_OPS = {
-    ast.Add: op.add,
-    ast.Sub: op.sub,
-    ast.Mult: op.mul,
-    ast.Div: op.truediv,
-    ast.FloorDiv: op.floordiv,
-    ast.Mod: op.mod,
-    ast.Pow: op.pow,
-    ast.USub: op.neg,
-    ast.UAdd: op.pos,
+_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):
+    def _eval(n: ast.AST) -> float:
         if isinstance(n, ast.Expression):
             return _eval(n.body)
-        if hasattr(ast, "Num") and isinstance(n, ast.Num):  # 3.8 and earlier
-            return n.n
-        if isinstance(n, ast.Constant):  # 3.8+
-            if isinstance(n.value, int | float):
-                return n.value
+        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) and type(n.op) in _OPS:
-            return _OPS[type(n.op)](_eval(n.left), _eval(n.right))
-        if isinstance(n, ast.UnaryOp) and type(n.op) in _OPS:
-            return _OPS[type(n.op)](_eval(n.operand))
+        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")
 
-    return _eval(node)
+    result = _eval(node)
+    return float(result)
 
 
 def register(cli):

synth_ai/cli/demo.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 """
-CLI: interactive launcher for example demos and forwarders for new RL demo.
+CLI: interactive launcher for example demos and RL demo helpers.
 
-- `synth-ai demo` (no subcommand) -> legacy examples/ runner (run_demo.sh picker)
-- `synth-ai demo deploy|configure|run` -> forwards to synth_ai.demos.core.cli
+- `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
@@ -14,6 +14,8 @@ from pathlib import Path
 
 import click
 
+from synth_ai.demos.core import cli as demo_commands
+
 
 def _find_demo_scripts(root: Path) -> list[Path]:
     if not root.exists():
@@ -21,17 +23,23 @@ def _find_demo_scripts(root: Path) -> list[Path]:
     return sorted([p for p in root.rglob("run_demo.sh") if p.is_file()])
 
 
-def _forward_to_new(args: list[str]) -> None:
-    import sys
+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 click.exceptions.Exit(exc.code or 1) from exc
+
+    if result is None:
+        return
 
     try:
-        from synth_ai.demos.core import cli as demo_cli  # type: ignore
-    except Exception as e:  # pragma: no cover
-        click.echo(f"Failed to import demo CLI: {e}")
-        sys.exit(1)
-    rc = int(demo_cli.main(args) or 0)
-    if rc != 0:
-        sys.exit(rc)
+        code = int(result)
+    except (TypeError, ValueError):
+        return
+    if code != 0:
+        raise click.exceptions.Exit(code)
 
 
 def register(cli):
@@ -92,11 +100,8 @@ def register(cli):
                 click.echo("\n🛑 Demo interrupted by user")
             return
 
-        # Default: forward to RL demo init behavior, optionally with --force
-        args: list[str] = ["rl_demo.init"]
-        if force:
-            args.append("--force")
-        _forward_to_new(args)
+        # Default: initialize RL demo files via new command
+        _run_demo_command(demo_commands.init, force=force)
 
     # (prepare command removed; configure now prepares baseline TOML)
 
@@ -122,24 +127,21 @@ def register(cli):
         help="Path to deploy_task_app.sh (optional legacy)",
     )
     def demo_deploy(local: bool, app: str | None, name: str, script: str | None):
-        args: list[str] = ["rl_demo.deploy"]
-        if local:
-            args.append("--local")
-        if app:
-            args.extend(["--app", app])
-        if name:
-            args.extend(["--name", name])
-        if script:
-            args.extend(["--script", script])
-        _forward_to_new(args)
+        _run_demo_command(
+            demo_commands.deploy,
+            local=local,
+            app=app,
+            name=name,
+            script=script,
+        )
 
     @_dg.command("configure")
     def demo_configure():
-        _forward_to_new(["rl_demo.configure"])
+        _run_demo_command(demo_commands.run)
 
     @_dg.command("setup")
     def demo_setup():
-        _forward_to_new(["rl_demo.setup"])
+        _run_demo_command(demo_commands.setup)
 
     @_dg.command("run")
     @click.option("--batch-size", type=int, default=None)
@@ -147,13 +149,10 @@ def register(cli):
     @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):
-        args = ["rl_demo.run"]
-        if batch_size is not None:
-            args.extend(["--batch-size", str(batch_size)])
-        if group_size is not None:
-            args.extend(["--group-size", str(group_size)])
-        if model:
-            args.extend(["--model", model])
-        if timeout:
-            args.extend(["--timeout", str(timeout)])
-        _forward_to_new(args)
+        _run_demo_command(
+            demo_commands.run,
+            batch_size=batch_size,
+            group_size=group_size,
+            model=model,
+            timeout=timeout,
+        )

synth_ai/cli/legacy_root_backup.py

@@ -3,6 +3,7 @@
 Synth AI CLI - Command line interface for Synth AI services.
 """
 
+import importlib
 import logging
 import os
 import shutil
@@ -12,6 +13,9 @@ import sys
 import time
 
 import click
+import requests
+from requests.exceptions import ConnectionError as RequestsConnectionError
+from requests.exceptions import HTTPError
 
 logger = logging.getLogger(__name__)
 
@@ -140,8 +144,6 @@ def register_env(
     name: str, module_path: str, class_name: str, description: str | None, service_url: str
 ):
     """Register a new environment with the service."""
-    import requests
-
     payload = {
         "name": name,
         "module_path": module_path,
@@ -157,10 +159,10 @@ def register_env(
         result = response.json()
         click.echo(f"✅ {result['message']}")
 
-    except requests.exceptions.ConnectionError:
+    except RequestsConnectionError:
         click.echo(f"❌ Could not connect to environment service at {service_url}")
         click.echo("💡 Make sure the service is running: synth-ai serve")
-    except requests.exceptions.HTTPError as e:
+    except HTTPError as e:
         error_detail = e.response.json().get("detail", str(e)) if e.response else str(e)
         click.echo(f"❌ Registration failed: {error_detail}")
     except Exception as e:
@@ -171,8 +173,6 @@ def register_env(
 @click.option("--service-url", default="http://localhost:8901", help="Environment service URL")
 def list_envs(service_url: str):
     """List all registered environments."""
-    import requests
-
     try:
         response = requests.get(f"{service_url}/registry/environments", timeout=10)
         response.raise_for_status()
@@ -195,7 +195,7 @@ def list_envs(service_url: str):
                 click.echo(f"   Description: {env['description']}")
             click.echo()
 
-    except requests.exceptions.ConnectionError:
+    except RequestsConnectionError:
         click.echo(f"❌ Could not connect to environment service at {service_url}")
         click.echo("💡 Make sure the service is running: synth-ai serve")
     except Exception as e:
@@ -207,8 +207,6 @@ def list_envs(service_url: str):
 @click.option("--service-url", default="http://localhost:8901", help="Environment service URL")
 def unregister_env(name: str, service_url: str):
     """Unregister an environment from the service."""
-    import requests
-
     try:
         response = requests.delete(f"{service_url}/registry/environments/{name}", timeout=10)
         response.raise_for_status()
@@ -216,10 +214,10 @@ def unregister_env(name: str, service_url: str):
         result = response.json()
         click.echo(f"✅ {result['message']}")
 
-    except requests.exceptions.ConnectionError:
+    except RequestsConnectionError:
         click.echo(f"❌ Could not connect to environment service at {service_url}")
         click.echo("💡 Make sure the service is running: synth-ai serve")
-    except requests.exceptions.HTTPError as e:
+    except HTTPError as e:
         if e.response.status_code == 404:
             click.echo(f"❌ Environment '{name}' not found in registry")
         else:
@@ -236,9 +234,9 @@ def unregister_env(name: str, service_url: str):
 def view(url: str):
     """Launch the interactive TUI dashboard."""
     try:
-        from .tui.dashboard import SynthDashboard
-
-        app = SynthDashboard(db_url=url)
+        module = importlib.import_module(".tui.dashboard", __package__)
+        synth_dashboard_cls = module.SynthDashboard
+        app = synth_dashboard_cls(db_url=url)
         app.run()
     except ImportError:
         click.echo("❌ Textual not installed. Install with: pip install textual", err=True)

synth_ai/cli/recent.py

@@ -5,40 +5,45 @@ CLI: experiments active in the last K hours with summary stats.
 
 import asyncio
 from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any
 
 import click
 from rich import box
 from rich.console import Console
 from rich.table import Table
 
+from ._storage import load_storage
 
-def _fmt_int(v) -> str:
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    import pandas as pd
+else:
+    pd = Any  # type: ignore[assignment]
+def _fmt_int(v: Any) -> str:
     try:
         return f"{int(v):,}"
     except Exception:
         return "0"
 
 
-def _fmt_money(v) -> str:
+def _fmt_money(v: Any) -> str:
     try:
         return f"${float(v or 0.0):.4f}"
     except Exception:
         return "$0.0000"
 
 
-def _fmt_time(v) -> str:
+def _fmt_time(v: Any) -> str:
     try:
         return str(v)
     except Exception:
         return "-"
 
 
-async def _fetch_recent(db_url: str, hours: float):
-from synth_ai.tracing_v3.storage.factory import create_storage, StorageConfig
-
+async def _fetch_recent(db_url: str, hours: float) -> "pd.DataFrame":
     start_time = datetime.now() - timedelta(hours=hours)
 
-    db = create_storage(StorageConfig(connection_string=db_url))
+    create_storage, storage_config = load_storage()
+    db: Any = create_storage(storage_config(connection_string=db_url))
     await db.initialize()
     try:
         query = """