synth-ai 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

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/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 = """

synth_ai/cli/status.py

@@ -12,11 +12,12 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
+from ._storage import load_storage
 
-async def _db_stats(db_url: str) -> dict:
-    from synth_ai.tracing_v3.storage.factory import StorageConfig, create_storage
 
-    db = create_storage(StorageConfig(connection_string=db_url))
+async def _db_stats(db_url: str) -> dict:
+    create_storage, storage_config = load_storage()
+    db = create_storage(storage_config(connection_string=db_url))
     await db.initialize()
     try:
         out: dict = {}