synth-ai 0.2.4.dev6__py3-none-any.whl → 0.2.4.dev7__py3-none-any.whl

synth_ai/cli/root.py

@@ -12,12 +12,11 @@ import signal
 import subprocess
 import sys
 import time
-from typing import Optional
 
 import click
 
 
-def find_sqld_binary() -> Optional[str]:
+def find_sqld_binary() -> str | None:
     sqld_path = shutil.which("sqld")
     if sqld_path:
         return sqld_path
@@ -78,9 +77,25 @@ def cli():
 @click.option("--env-port", default=8901, type=int, help="Port for environment service")
 @click.option("--no-sqld", is_flag=True, help="Skip starting sqld daemon")
 @click.option("--no-env", is_flag=True, help="Skip starting environment service")
-@click.option("--reload/--no-reload", default=False, help="Enable auto-reload (default: off). Or set SYNTH_RELOAD=1")
-@click.option("--force/--no-force", default=True, help="Kill any process already bound to --env-port without prompting")
-def serve(db_file: str, sqld_port: int, env_port: int, no_sqld: bool, no_env: bool, reload: bool, force: bool):
+@click.option(
+    "--reload/--no-reload",
+    default=False,
+    help="Enable auto-reload (default: off). Or set SYNTH_RELOAD=1",
+)
+@click.option(
+    "--force/--no-force",
+    default=True,
+    help="Kill any process already bound to --env-port without prompting",
+)
+def serve(
+    db_file: str,
+    sqld_port: int,
+    env_port: int,
+    no_sqld: bool,
+    no_env: bool,
+    reload: bool,
+    force: bool,
+):
     logging.basicConfig(level=logging.INFO, format="%(message)s")
     processes = []
 
@@ -100,11 +115,25 @@ def serve(db_file: str, sqld_port: int, env_port: int, no_sqld: bool, no_env: bo
 
     if not no_sqld:
         try:
-            result = subprocess.run(["pgrep", "-f", f"sqld.*--http-listen-addr.*:{sqld_port}"], capture_output=True, text=True)
+            result = subprocess.run(
+                ["pgrep", "-f", f"sqld.*--http-listen-addr.*:{sqld_port}"],
+                capture_output=True,
+                text=True,
+            )
             if result.returncode != 0:
                 sqld_bin = find_sqld_binary() or install_sqld()
                 click.echo(f"🗄️  Starting sqld (local only) on port {sqld_port}")
-                proc = subprocess.Popen([sqld_bin, "--db-path", db_file, "--http-listen-addr", f"127.0.0.1:{sqld_port}"], stdout=open("sqld.log", "w"), stderr=subprocess.STDOUT)
+                proc = subprocess.Popen(
+                    [
+                        sqld_bin,
+                        "--db-path",
+                        db_file,
+                        "--http-listen-addr",
+                        f"127.0.0.1:{sqld_port}",
+                    ],
+                    stdout=open("sqld.log", "w"),  # noqa: SIM115
+                    stderr=subprocess.STDOUT,
+                )
                 processes.append(proc)
                 time.sleep(2)
         except FileNotFoundError:
@@ -118,6 +147,7 @@ def serve(db_file: str, sqld_port: int, env_port: int, no_sqld: bool, no_env: bo
         # Ensure port is free
         try:
             import socket
+
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                 in_use = s.connect_ex(("127.0.0.1", env_port)) == 0
         except Exception:
@@ -125,7 +155,9 @@ def serve(db_file: str, sqld_port: int, env_port: int, no_sqld: bool, no_env: bo
         if in_use:
             pids: list[str] = []
             try:
-                out = subprocess.run(["lsof", "-ti", f":{env_port}"], capture_output=True, text=True)
+                out = subprocess.run(
+                    ["lsof", "-ti", f":{env_port}"], capture_output=True, text=True
+                )
                 if out.returncode == 0 and out.stdout.strip():
                     pids = [p for p in out.stdout.strip().splitlines() if p]
             except FileNotFoundError:
@@ -136,7 +168,9 @@ def serve(db_file: str, sqld_port: int, env_port: int, no_sqld: bool, no_env: bo
                     time.sleep(0.5)
             else:
                 suffix = f" PIDs: {', '.join(pids)}" if pids else ""
-                if click.confirm(f"⚠️  Port {env_port} is in use.{suffix} Kill and continue?", default=True):
+                if click.confirm(
+                    f"⚠️  Port {env_port} is in use.{suffix} Kill and continue?", default=True
+                ):
                     if pids:
                         subprocess.run(["kill", "-9", *pids], check=False)
                         time.sleep(0.5)
@@ -158,12 +192,24 @@ def serve(db_file: str, sqld_port: int, env_port: int, no_sqld: bool, no_env: bo
         click.echo("   - Check sqld.log if database issues occur")
         click.echo("   - Use Ctrl+C to stop all services")
         reload_enabled = reload or (os.getenv("SYNTH_RELOAD", "0") == "1")
-        click.echo("   - Auto-reload ENABLED (code changes restart service)" if reload_enabled else "   - Auto-reload DISABLED (stable in-memory sessions)")
+        click.echo(
+            "   - Auto-reload ENABLED (code changes restart service)"
+            if reload_enabled
+            else "   - Auto-reload DISABLED (stable in-memory sessions)"
+        )
         click.echo("")
 
         uvicorn_cmd = [
-            sys.executable, "-m", "uvicorn", "synth_ai.environments.service.app:app",
-            "--host", "0.0.0.0", "--port", str(env_port), "--log-level", "info",
+            sys.executable,
+            "-m",
+            "uvicorn",
+            "synth_ai.environments.service.app:app",
+            "--host",
+            "0.0.0.0",
+            "--port",
+            str(env_port),
+            "--log-level",
+            "info",
         ]
         if reload_enabled:
             uvicorn_cmd.append("--reload")
@@ -181,4 +227,3 @@ def serve(db_file: str, sqld_port: int, env_port: int, no_sqld: bool, no_env: bo
             pass
     else:
         click.echo("No services to start.")
-

synth_ai/cli/status.py

@@ -4,14 +4,13 @@ CLI: status of agent runs/versions and environment service.
 """
 
 import asyncio
-from typing import Optional
 
 import click
+import requests
+from rich import box
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-from rich import box
-import requests
 
 
 async def _db_stats(db_url: str) -> dict:
@@ -52,7 +51,7 @@ async def _db_stats(db_url: str) -> dict:
         """
         )
         if not versions.empty:
-            out["version_count"] = int(versions.iloc[0]["version_count"]) 
+            out["version_count"] = int(versions.iloc[0]["version_count"])
         else:
             out["version_count"] = 0
         return out
@@ -108,7 +107,11 @@ def register(cli):
             lines.append("")
             lines.append(f"Env Service: {health_text}  [dim]{service_url}[/dim]")
             if envs_list:
-                lines.append("Environments: " + ", ".join(sorted(envs_list)[:10]) + (" ..." if len(envs_list) > 10 else ""))
+                lines.append(
+                    "Environments: "
+                    + ", ".join(sorted(envs_list)[:10])
+                    + (" ..." if len(envs_list) > 10 else "")
+                )
 
             panel_main = Panel("\n".join(lines), title="Synth AI Status", border_style="cyan")
             console.print(panel_main)
@@ -116,7 +119,11 @@ def register(cli):
             # Systems table
             sys_df = stats.get("systems")
             if sys_df is not None and not sys_df.empty:
-                tbl = Table(title=f"Systems (versions: {stats.get('version_count', 0)})", box=box.SIMPLE, header_style="bold")
+                tbl = Table(
+                    title=f"Systems (versions: {stats.get('version_count', 0)})",
+                    box=box.SIMPLE,
+                    header_style="bold",
+                )
                 tbl.add_column("Type")
                 tbl.add_column("Count", justify="right")
                 for _, r in sys_df.iterrows():

synth_ai/cli/traces.py

@@ -3,14 +3,13 @@
 CLI: basic info about traces (runs).
 """
 
-import os
 import asyncio
-from typing import Optional, Dict, Tuple, List
+import os
 
 import click
+from rich import box
 from rich.console import Console
 from rich.table import Table
-from rich import box
 
 
 def register(cli):
@@ -35,7 +34,7 @@ def register(cli):
                 console.print(f"[red]No DB root found:[/red] {root}")
                 return
 
-            entries: List[Tuple[str, str]] = []
+            entries: list[tuple[str, str]] = []
             for name in sorted(os.listdir(root)):
                 path = os.path.join(root, name)
                 data_path = os.path.join(path, "data")
@@ -51,38 +50,53 @@ def register(cli):
                 for dp, _, files in os.walk(dir_path):
                     for fn in files:
                         fp = os.path.join(dp, fn)
-                        try:
+                        import contextlib
+                        with contextlib.suppress(OSError):
                             total += os.path.getsize(fp)
-                        except OSError:
-                            pass
                 return total
 
-            async def db_counts(db_dir: str) -> Tuple[int, Dict[str, int], int, Optional[str], int]:
+            async def db_counts(db_dir: str) -> tuple[int, dict[str, int], int, str | None, int]:
                 data_file = os.path.join(db_dir, "data")
                 mgr = AsyncSQLTraceManager(f"sqlite+aiosqlite:///{data_file}")
                 await mgr.initialize()
                 try:
                     traces_df = await mgr.query_traces("SELECT COUNT(*) AS c FROM session_traces")
-                    traces_count = int(traces_df.iloc[0]["c"]) if traces_df is not None and not traces_df.empty else 0
+                    traces_count = (
+                        int(traces_df.iloc[0]["c"])
+                        if traces_df is not None and not traces_df.empty
+                        else 0
+                    )
                     try:
                         systems_df = await mgr.query_traces(
                             "SELECT system_type, COUNT(*) AS c FROM systems GROUP BY system_type"
                         )
-                        system_counts = {
-                            str(r["system_type"] or "-"): int(r["c"] or 0)
-                            for _, r in (systems_df or []).iterrows()
-                        } if systems_df is not None and not systems_df.empty else {}
+                        system_counts = (
+                            {
+                                str(r["system_type"] or "-"): int(r["c"] or 0)
+                                for _, r in (systems_df or []).iterrows()
+                            }
+                            if systems_df is not None and not systems_df.empty
+                            else {}
+                        )
                     except Exception:
                         system_counts = {}
                     try:
                         exps_df = await mgr.query_traces("SELECT COUNT(*) AS c FROM experiments")
-                        exps_count = int(exps_df.iloc[0]["c"]) if exps_df is not None and not exps_df.empty else 0
+                        exps_count = (
+                            int(exps_df.iloc[0]["c"])
+                            if exps_df is not None and not exps_df.empty
+                            else 0
+                        )
                     except Exception:
                         exps_count = 0
                     try:
-                        last_df = await mgr.query_traces("SELECT MAX(created_at) AS last_created_at FROM session_traces")
+                        last_df = await mgr.query_traces(
+                            "SELECT MAX(created_at) AS last_created_at FROM session_traces"
+                        )
                         last_created = (
-                            str(last_df.iloc[0]["last_created_at"]) if last_df is not None and not last_df.empty else None
+                            str(last_df.iloc[0]["last_created_at"])
+                            if last_df is not None and not last_df.empty
+                            else None
                         )
                     except Exception:
                         last_created = None
@@ -102,13 +116,21 @@ def register(cli):
             # DB summary table
             summary = Table(title="Trace Databases", box=box.SIMPLE, header_style="bold")
             for col in ["DB", "Traces", "Experiments", "Last Activity", "Size (GB)"]:
-                summary.add_column(col, justify="right" if col in {"Traces", "Experiments"} else "left")
+                summary.add_column(
+                    col, justify="right" if col in {"Traces", "Experiments"} else "left"
+                )
 
-            aggregate_systems: Dict[str, int] = {}
+            aggregate_systems: dict[str, int] = {}
             total_bytes = 0
-            for name, (traces_count, system_counts, experiments_count, last_created_at, size_bytes) in results:
+            for name, (
+                traces_count,
+                system_counts,
+                experiments_count,
+                last_created_at,
+                size_bytes,
+            ) in results:
                 total_bytes += int(size_bytes or 0)
-                gb = (int(size_bytes or 0) / (1024**3))
+                gb = int(size_bytes or 0) / (1024**3)
                 summary.add_row(
                     name,
                     f"{traces_count:,}",
@@ -129,7 +151,9 @@ def register(cli):
                 st = Table(title="Per-System (all DBs)", box=box.SIMPLE, header_style="bold")
                 st.add_column("System")
                 st.add_column("Count", justify="right")
-                for sys_name, count in sorted(aggregate_systems.items(), key=lambda x: (-x[1], x[0])):
+                for sys_name, count in sorted(
+                    aggregate_systems.items(), key=lambda x: (-x[1], x[0])
+                ):
                     st.add_row(sys_name or "-", f"{int(count):,}")
                 console.print(st)
 

synth_ai/cli/watch.py

@@ -7,26 +7,24 @@ Placed beside scope.txt for discoverability.
 
 import asyncio
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 import click
+from rich import box
+from rich.align import Align
 from rich.console import Console, Group
-from rich.table import Table
 from rich.panel import Panel
-from rich.align import Align
-from rich.live import Live
-from rich import box
-import sys
+from rich.table import Table
 
 
 class _State:
     def __init__(self):
         self.view: str = "experiments"  # experiments | experiment | usage | traces | recent
-        self.view_arg: Optional[str] = None
+        self.view_arg: str | None = None
         self.limit: int = 20
         self.hours: float = 24.0
         self.last_msg: str = "Type 'help' for commands. 'q' to quit."
-        self.error: Optional[str] = None
+        self.error: str | None = None
         # UI state for a visible, blinking cursor in the input field
         self.cursor_on: bool = True
 
@@ -80,7 +78,7 @@ async def _fetch_experiments(db_url: str):
         await db.close()
 
 
-def _experiments_table(df, limit: Optional[int] = None) -> Table:
+def _experiments_table(df, limit: int | None = None) -> Table:
     table = Table(
         title="Synth AI Experiments",
         title_style="bold cyan",
@@ -90,15 +88,15 @@ def _experiments_table(df, limit: Optional[int] = None) -> Table:
         pad_edge=False,
     )
     for col in ["ID", "Name", "Sessions", "Events", "Msgs", "Cost", "Tokens", "Created"]:
-        table.add_column(col, justify="right" if col in {"Sessions","Events","Msgs","Tokens"} else "left")
+        table.add_column(
+            col, justify="right" if col in {"Sessions", "Events", "Msgs", "Tokens"} else "left"
+        )
 
     if df is not None and not df.empty:
         rows = df.itertuples(index=False)
-        count = 0
-        for row in rows:
-            if limit is not None and count >= limit:
+        for count, row in enumerate(rows, start=1):
+            if limit is not None and count > limit:
                 break
-            count += 1
             table.add_row(
                 _short_id(getattr(row, "experiment_id", "")),
                 str(getattr(row, "name", "Unnamed"))[:28],
@@ -115,7 +113,7 @@ def _experiments_table(df, limit: Optional[int] = None) -> Table:
     return table
 
 
-async def _experiment_detail(db_url: str, experiment_id: str) -> Dict[str, Any]:
+async def _experiment_detail(db_url: str, experiment_id: str) -> dict[str, Any]:
     from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
 
     db = AsyncSQLTraceManager(db_url)
@@ -158,22 +156,24 @@ async def _experiment_detail(db_url: str, experiment_id: str) -> Dict[str, Any]:
         await db.close()
 
 
-def _render_experiment_panel(detail: Dict[str, Any]) -> Panel:
+def _render_experiment_panel(detail: dict[str, Any]) -> Panel:
     if detail.get("not_found"):
         return Panel("No experiment found for given ID", title="Experiment", border_style="red")
 
     exp = detail["experiment"]
     stats = detail.get("stats")
-    lines: List[str] = []
+    lines: list[str] = []
     lines.append(f"[bold]🧪 {exp['name']}[/bold]  ([dim]{exp['experiment_id']}[/dim])")
     if exp.get("description"):
-        lines.append(exp["description"]) 
+        lines.append(exp["description"])
     lines.append("")
     if stats is not None:
-        lines.append(f"[bold]Stats[/bold]  Events: {_format_int(stats['total_events'])}  "
-                     f"Messages: {_format_int(stats['total_messages'])}  "
-                     f"Cost: {_format_currency(float(stats['total_cost'] or 0.0))}  "
-                     f"Tokens: {_format_int(stats['total_tokens'])}")
+        lines.append(
+            f"[bold]Stats[/bold]  Events: {_format_int(stats['total_events'])}  "
+            f"Messages: {_format_int(stats['total_messages'])}  "
+            f"Cost: {_format_currency(float(stats['total_cost'] or 0.0))}  "
+            f"Tokens: {_format_int(stats['total_tokens'])}"
+        )
     lines.append(f"Created: {exp['created_at']}")
     lines.append("")
     sessions = detail.get("sessions", [])
@@ -215,7 +215,8 @@ def register(cli):
             console.print(table)
             console.print(
                 "\n[dim]Tip:[/dim] use [cyan]synth-ai experiment <id>[/cyan] for details, "
-                "[cyan]synth-ai usage[/cyan] for model usage.", sep="",
+                "[cyan]synth-ai usage[/cyan] for model usage.",
+                sep="",
             )
 
         asyncio.run(_run())
@@ -247,12 +248,13 @@ def register(cli):
         help="Database URL",
     )
     @click.option("--model", "model_name", default=None, help="Filter by model name")
-    def usage(db_url: str, model_name: Optional[str]):
+    def usage(db_url: str, model_name: str | None):
         """Show model usage statistics (tokens, cost)."""
         console = Console()
 
         async def _run():
             from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+
             db = AsyncSQLTraceManager(db_url)
             await db.initialize()
             try:
@@ -379,7 +381,7 @@ async def _handle_command(cmd: str, state: _State):
     state.last_msg = f"Unknown command: {cmd}"
 
 
-def _parse_hours(args: List[str]) -> Optional[float]:
+def _parse_hours(args: list[str]) -> float | None:
     if not args:
         return None
     # Accept formats: "6", "--6", "-6", "6h"
@@ -393,8 +395,9 @@ def _parse_hours(args: List[str]) -> Optional[float]:
         return None
 
 
-async def _usage_table(db_url: str, model_name: Optional[str]):
+async def _usage_table(db_url: str, model_name: str | None):
     from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+
     db = AsyncSQLTraceManager(db_url)
     await db.initialize()
     try:
@@ -416,6 +419,7 @@ async def _usage_table(db_url: str, model_name: Optional[str]):
 
 async def _traces_table(db_url: str, limit: int):
     from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+
     db = AsyncSQLTraceManager(db_url)
     await db.initialize()
     try:
@@ -425,16 +429,14 @@ async def _traces_table(db_url: str, limit: int):
 
     table = Table(title="Recent Sessions", box=box.SIMPLE, header_style="bold")
     for col in ["Session", "Experiment", "Events", "Msgs", "Timesteps", "Cost", "Created"]:
-        table.add_column(col, justify="right" if col in {"Events","Msgs","Timesteps"} else "left")
+        table.add_column(col, justify="right" if col in {"Events", "Msgs", "Timesteps"} else "left")
 
     if df is None or df.empty:
         table.add_row("-", "No sessions found", "-", "-", "-", "-", "-")
     else:
-        count = 0
-        for _, r in df.iterrows():
-            if count >= limit:
+        for count, (_, r) in enumerate(df.iterrows(), start=1):
+            if count > limit:
                 break
-            count += 1
             table.add_row(
                 str(r.get("session_id", ""))[:10],
                 str(r.get("experiment_name", ""))[:24],
@@ -450,6 +452,7 @@ async def _traces_table(db_url: str, limit: int):
 async def _recent_table(db_url: str, hours: float, limit: int):
     # Inline the recent query to avoid cross-module coupling
     from datetime import timedelta
+
     from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
 
     start_time = datetime.now() - timedelta(hours=hours)
@@ -483,18 +486,18 @@ async def _recent_table(db_url: str, hours: float, limit: int):
 
     table = Table(title=f"Experiments in last {hours:g}h", header_style="bold", box=box.SIMPLE)
     for col in ["Experiment", "Runs", "First", "Last", "Events", "Msgs", "Cost", "Tokens"]:
-        table.add_column(col, justify="right" if col in {"Runs","Events","Msgs","Tokens"} else "left")
+        table.add_column(
+            col, justify="right" if col in {"Runs", "Events", "Msgs", "Tokens"} else "left"
+        )
 
     if df is None or df.empty:
         table.add_row("-", "0", "-", "-", "-", "-", "-", "-")
     else:
-        count = 0
-        for _, r in df.iterrows():
-            if count >= limit:
+        for count, (_, r) in enumerate(df.iterrows(), start=1):
+            if count > limit:
                 break
-            count += 1
             name = r.get("name") or "Unnamed"
-            exp_disp = f"{name[:28]} [dim]({(str(r.get('experiment_id',''))[:8])})[/dim]"
+            exp_disp = f"{name[:28]} [dim]({(str(r.get('experiment_id', ''))[:8])})[/dim]"
             table.add_row(
                 exp_disp,
                 f"{int(r.get('runs', 0)):,}",

synth_ai/config/base_url.py

@@ -14,7 +14,6 @@ Normalization: ensure the returned URL ends with "/api".
 import os
 from typing import Literal
 
-
 PROD_BASE_URL_DEFAULT = "https://agent-learning.onrender.com"
 
 
@@ -28,7 +27,7 @@ def _normalize_base(url: str) -> str:
     return url
 
 
-def get_learning_v2_base_url(mode: Literal["dev","prod"] = "prod") -> str:
+def get_learning_v2_base_url(mode: Literal["dev", "prod"] = "prod") -> str:
     if mode == "prod":
         prod = os.getenv("SYNTH_PROD_BASE_URL") or PROD_BASE_URL_DEFAULT
         return _normalize_base(prod)
@@ -50,4 +49,3 @@ def get_learning_v2_base_url(mode: Literal["dev","prod"] = "prod") -> str:
         return _normalize_base(dev)
 
     raise Exception()
-

synth_ai/core/experiment.py

@@ -1,4 +1,3 @@
-from typing import List
 
 
 class ExperimentalSystem:
@@ -13,4 +12,4 @@ class Experiment:
     description: str
     created_at: str
     updated_at: str
-    related_systems: List[ExperimentalSystem]
+    related_systems: list[ExperimentalSystem]

synth_ai/environments/__init__.py

@@ -3,11 +3,7 @@
 __version__ = "0.1.5"
 
 # Import key modules for easier access
-from . import environment
-from . import service
-from . import stateful
-from . import tasks
-from . import examples
+from . import environment, examples, service, stateful, tasks
 
 __all__ = [
     "environment",
@@ -32,4 +28,4 @@ if "src" not in sys.modules:
 
 # Expose this package as src.synth_env
 sys.modules["src.synth_env"] = sys.modules[__name__]
-setattr(sys.modules["src"], "synth_env", sys.modules[__name__])
+sys.modules["src"].synth_env = sys.modules[__name__]

synth_ai/environments/environment/artifacts/base.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
+
+import shutil
 from abc import ABC, abstractmethod
 from pathlib import Path
+
 from pydantic import BaseModel
-import shutil
 
 
 class Artifact(BaseModel, ABC):

synth_ai/environments/environment/db/sqlite.py

@@ -1,6 +1,6 @@
+import contextlib
 import sqlite3
 import threading
-import contextlib
 from pathlib import Path