synth-ai 0.2.9.dev0__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

synth_ai/cli/deploy.py

@@ -0,0 +1,233 @@
+import asyncio
+import os
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Literal, TypeAlias, cast, get_args
+
+import click
+from synth_ai.cfgs import CloudflareTunnelDeployCfg, LocalDeployCfg, ModalDeployCfg
+from synth_ai.modal import deploy_app_modal
+from synth_ai.tunnel_deploy import deploy_app_tunnel
+from synth_ai.utils import (
+    PromptedChoiceOption,
+    PromptedChoiceType,
+    PromptedPathOption,
+    flush_logger,
+    log_error,
+    log_info,
+    read_env_var_from_file,
+    validate_task_app,
+)
+from synth_ai.uvicorn import deploy_app_uvicorn
+
+RuntimeType: TypeAlias = Literal[
+    "local",
+    "modal",
+    "tunnel"
+]
+
+
+RUNTIME_MSG = SimpleNamespace(
+    init="[deploy]",
+    local="[deploy --runtime local]",
+    modal="[deploy --runtime modal]",
+    tunnel="[deploy --runtime tunnel]",
+)
+
+
+@click.command()
+# --- Required options ---
+@click.option(
+    "--task-app",
+    "task_app_path",
+    cls=PromptedPathOption,
+    type=click.Path(
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        path_type=Path
+    ),
+    file_type=".py",
+    help="Enter the path to your task app",
+)
+@click.option(
+    "--runtime",
+    "runtime",
+    cls=PromptedChoiceOption,
+    type=PromptedChoiceType(get_args(RuntimeType)),
+    required=True
+)
+# --- Optional option ---
+@click.option(
+    "--env",
+    "env_path",
+    type=click.Path(
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        path_type=Path
+    ),
+    help="Path to .env file to use"
+)
+# --- Local runtime-only options ---
+@click.option(
+    "--trace/--no-trace",
+    "trace",
+    default=True,
+    help="Enable or disable trace output"
+)
+@click.option(
+    "--host",
+    "host",
+    default="127.0.0.1", 
+    help="Host to bind to"
+)
+@click.option(
+    "--port",
+    "port",
+    default=8000,
+    type=int,
+    help=f"{RUNTIME_MSG.local} Port to bind to"
+)
+# --- Tunnel runtime-only options ---
+@click.option(
+    "--tunnel-mode",
+    "tunnel_mode",
+    type=click.Choice(["quick", "managed"], case_sensitive=False),
+    default="quick",
+    help="Tunnel mode: quick (ephemeral) or managed (stable)"
+)
+@click.option(
+    "--tunnel-subdomain",
+    "tunnel_subdomain",
+    type=str,
+    default=None,
+    help="Custom subdomain for managed tunnel (e.g., 'my-company')"
+)
+@click.option(
+    "--keep-alive/--background",
+    "keep_alive",
+    default=False,
+    help="Keep tunnel alive (blocking mode). Default is background (non-blocking)"
+)
+# --- Modal runtime-only options ---
+@click.option(
+    "--modal-app",
+    "modal_app_path",
+    cls=PromptedPathOption,
+    type=click.Path(
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        path_type=Path
+    ),
+    file_type=".py",
+    prompt_guard=lambda ctx: (ctx.params.get("runtime") not in ("local", "tunnel")),
+    help="Enter the path to your Modal app"
+)
+@click.option(
+    "--name",
+    "task_app_name",
+    default=None,
+    help="Override Modal app name"
+)
+@click.option(
+    "--modal-mode",
+    "cmd_arg",
+    default="deploy",
+    help="Mode: deploy or serve"
+)
+@click.option(
+    "--modal-cli",
+    "modal_bin_path",
+    type=click.Path(
+        dir_okay=False,
+        file_okay=True,
+        exists=True,
+        path_type=Path
+    ),
+    default=None,
+    help="Path to Modal CLI",
+)
+@click.option(
+    "--dry-run",
+    "dry_run",
+    is_flag=True,
+    help="Print Modal command without executing"
+)
+def deploy_cmd(
+    task_app_path: Path,
+    runtime: RuntimeType,
+    **kwargs
+) -> None:
+    try:
+        log_info("deploy command invoked", ctx={"runtime": runtime})
+        env_file_path = kwargs.pop("env_path", None)
+        file_synth_api_key = None
+        file_env_api_key = None
+        if env_file_path is not None:
+            file_synth_api_key = read_env_var_from_file("SYNTH_API_KEY", env_file_path)
+            file_env_api_key = read_env_var_from_file("ENVIRONMENT_API_KEY", env_file_path)
+        env_synth_api_key = os.environ.get("SYNTH_API_KEY")
+        env_env_api_key = os.environ.get("ENVIRONMENT_API_KEY")
+        synth_api_key = file_synth_api_key or env_synth_api_key
+        env_api_key = file_env_api_key or env_env_api_key
+        if not synth_api_key:
+            raise RuntimeError("SYNTH_API_KEY not in process environment. Either run synth-ai setup to load automatically or manually load to process environment or pass .env via synth-ai deploy --env .env")
+        if not env_api_key:
+            log_error("ENVIRONMENT_API_KEY_MISSING", ctx={"runtime": runtime})
+            raise RuntimeError("ENVIRONMENT_API_KEY not in process environment. Either run synth-ai setup to load automatically or manually load to process environment or pass .env via synth-ai deploy --env .env")
+        
+        validate_task_app(task_app_path)
+
+        match runtime:
+            case "local":
+                log_info("starting local deploy")
+                deploy_app_uvicorn(LocalDeployCfg.create(
+                    task_app_path=task_app_path,
+                    env_api_key=env_api_key,
+                    trace = bool(kwargs.get("trace", True)),
+                    host = str(kwargs.get("host", "127.0.0.1")),
+                    port = int(kwargs.get("port", 8000))
+                ))
+            case "modal":
+                log_info("starting modal deploy")
+                deploy_app_modal(ModalDeployCfg.create_from_kwargs(
+                    task_app_path=task_app_path,
+                    synth_api_key=synth_api_key,
+                    env_api_key=env_api_key,
+                    **kwargs
+                ))
+            case "tunnel":
+                # For managed tunnels, SYNTH_API_KEY is required
+                tunnel_mode = kwargs.get("tunnel_mode", "managed")
+                if tunnel_mode == "managed" and not synth_api_key:
+                    raise RuntimeError(
+                        "SYNTH_API_KEY required for managed tunnel mode. "
+                        "Either run synth-ai setup to load automatically or manually load to process environment or pass .env via synth-ai deploy --env .env"
+                    )
+                
+                cfg = CloudflareTunnelDeployCfg.create(
+                    task_app_path=task_app_path,
+                    env_api_key=env_api_key,
+                    host=str(kwargs.get("host", "127.0.0.1")),
+                    port=int(kwargs.get("port", 8000)),
+                    mode=cast(Literal["quick", "managed"], tunnel_mode),
+                    subdomain=kwargs.get("tunnel_subdomain"),
+                    trace=bool(kwargs.get("trace", True)),
+                )
+                # Default to background mode (non-blocking), use --keep-alive for blocking
+                keep_alive = bool(kwargs.get("keep_alive", False))
+                asyncio.run(deploy_app_tunnel(cfg, env_file_path, keep_alive=keep_alive))
+                # Note: deploy_app_tunnel prints the URL and status message internally
+        log_info("deploy command completed", ctx={"runtime": runtime})
+    except Exception as exc:
+        log_error("deploy command failed", ctx={
+            "runtime": runtime,
+            "task_app": str(task_app_path),
+            "error": type(exc).__name__,
+            "error_message": str(exc)
+        })
+        click.echo(f"{exc}", err=True)
+    finally:
+        flush_logger(0.5)

synth_ai/cli/eval/__init__.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from .core import command, get_command
+from .errors import (
+    EvalCliError,
+    EvalConfigNotFoundError,
+    EvalConfigParseError,
+    InvalidEvalConfigError,
+    MetadataFilterFormatError,
+    MetadataSQLExecutionError,
+    MetadataSQLResultError,
+    MissingEvalTableError,
+    NoSeedsMatchedError,
+    SeedParseError,
+    TaskInfoUnavailableError,
+    TomlUnavailableError,
+)
+from .validation import validate_eval_options
+
+__all__ = [
+    "command",
+    "get_command",
+    "EvalCliError",
+    "TomlUnavailableError",
+    "EvalConfigNotFoundError",
+    "EvalConfigParseError",
+    "MissingEvalTableError",
+    "InvalidEvalConfigError",
+    "SeedParseError",
+    "MetadataFilterFormatError",
+    "TaskInfoUnavailableError",
+    "NoSeedsMatchedError",
+    "MetadataSQLExecutionError",
+    "MetadataSQLResultError",
+    "validate_eval_options",
+]

synth_ai/cli/eval/core.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from synth_ai.cli.commands.eval.core import command, get_command
+
+__all__ = ["command", "get_command"]

synth_ai/cli/eval/errors.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from synth_ai.cli.commands.eval.errors import (
+    EvalCliError,
+    EvalConfigNotFoundError,
+    EvalConfigParseError,
+    InvalidEvalConfigError,
+    MetadataFilterFormatError,
+    MetadataSQLExecutionError,
+    MetadataSQLResultError,
+    MissingEvalTableError,
+    NoSeedsMatchedError,
+    SeedParseError,
+    TaskInfoUnavailableError,
+    TomlUnavailableError,
+)
+
+__all__ = [
+    "EvalCliError",
+    "TomlUnavailableError",
+    "EvalConfigNotFoundError",
+    "EvalConfigParseError",
+    "MissingEvalTableError",
+    "InvalidEvalConfigError",
+    "SeedParseError",
+    "MetadataFilterFormatError",
+    "TaskInfoUnavailableError",
+    "NoSeedsMatchedError",
+    "MetadataSQLExecutionError",
+    "MetadataSQLResultError",
+]

synth_ai/cli/eval/validation.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from synth_ai.cli.commands.eval.validation import validate_eval_options
+
+__all__ = ["validate_eval_options"]

synth_ai/cli/filter/__init__.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from .core import command, get_command
+from .errors import (
+    FilterCliError,
+    FilterConfigNotFoundError,
+    FilterConfigParseError,
+    InvalidFilterConfigError,
+    MissingFilterTableError,
+    NoSessionsMatchedError,
+    NoTracesFoundError,
+    TomlUnavailableError,
+)
+from .validation import validate_filter_options
+
+__all__ = [
+    "command",
+    "get_command",
+    "FilterCliError",
+    "TomlUnavailableError",
+    "FilterConfigNotFoundError",
+    "FilterConfigParseError",
+    "MissingFilterTableError",
+    "InvalidFilterConfigError",
+    "NoTracesFoundError",
+    "NoSessionsMatchedError",
+    "validate_filter_options",
+]

synth_ai/cli/filter/core.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from synth_ai.cli.commands.filter.core import command, get_command
+
+__all__ = ["command", "get_command"]

synth_ai/cli/filter/errors.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from synth_ai.cli.commands.filter.errors import (
+    FilterCliError,
+    FilterConfigNotFoundError,
+    FilterConfigParseError,
+    InvalidFilterConfigError,
+    MissingFilterTableError,
+    NoSessionsMatchedError,
+    NoTracesFoundError,
+    TomlUnavailableError,
+)
+
+__all__ = [
+    "FilterCliError",
+    "TomlUnavailableError",
+    "FilterConfigNotFoundError",
+    "FilterConfigParseError",
+    "MissingFilterTableError",
+    "InvalidFilterConfigError",
+    "NoTracesFoundError",
+    "NoSessionsMatchedError",
+]

synth_ai/cli/filter/validation.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from synth_ai.cli.commands.filter.validation import validate_filter_options
+
+__all__ = ["validate_filter_options"]

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,11 @@ 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 = getattr(module, "SynthDashboard", None)
+        if synth_dashboard_cls is None:
+            raise RuntimeError("SynthDashboard class not available")
+        app = synth_dashboard_cls(db_url=url)
         app.run()
     except ImportError:
         click.echo("❌ Textual not installed. Install with: pip install textual", err=True)
@@ -253,7 +253,7 @@ def view(url: str):
 
 @cli.command()
 @click.option("--db-file", default="synth_ai.db", help="Database file path")
-@click.option("--sqld-port", default=8080, type=int, help="Port for sqld HTTP interface")
+@click.option("--sqld-port", default=8080, type=int, help="Port for sqld Hrana WebSocket interface (HTTP API will be port+1)")
 @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")
@@ -298,32 +298,37 @@ def serve(
 
     # Start sqld if requested
     if not no_sqld:
+        hrana_port = sqld_port
+        http_port = sqld_port + 1
         # Check if sqld is already running
         try:
             result = subprocess.run(
-                ["pgrep", "-f", f"sqld.*--http-listen-addr.*:{sqld_port}"],
+                ["pgrep", "-f", f"sqld.*(--hrana-listen-addr.*:{hrana_port}|--http-listen-addr.*:{http_port})"],
                 capture_output=True,
                 text=True,
             )
             if result.returncode == 0:
-                click.echo(f"✅ sqld already running on port {sqld_port}")
+                click.echo(f"✅ sqld already running on hrana port {hrana_port}, HTTP API port {http_port}")
                 click.echo(f"   Database: {db_file}")
-                click.echo(f"   HTTP API: http://127.0.0.1:{sqld_port}")
+                click.echo(f"   libsql: libsql://127.0.0.1:{hrana_port}")
+                click.echo(f"   HTTP API: http://127.0.0.1:{http_port}")
             else:
                 # Find or install sqld
                 sqld_bin = find_sqld_binary()
                 if not sqld_bin:
                     sqld_bin = install_sqld()
 
-                click.echo(f"🗄️  Starting sqld (local only) on port {sqld_port}")
+                click.echo(f"🗄️  Starting sqld (local only) on hrana port {hrana_port}, HTTP API port {http_port}")
 
                 # Start sqld
                 sqld_cmd = [
                     sqld_bin,
                     "--db-path",
                     db_file,
+                    "--hrana-listen-addr",
+                    f"127.0.0.1:{hrana_port}",
                     "--http-listen-addr",
-                    f"127.0.0.1:{sqld_port}",
+                    f"127.0.0.1:{http_port}",
                 ]
 
                 # Create log file
@@ -346,7 +351,8 @@ def serve(
 
                 click.echo("✅ sqld started successfully!")
                 click.echo(f"   Database: {db_file}")
-                click.echo(f"   HTTP API: http://127.0.0.1:{sqld_port}")
+                click.echo(f"   libsql: libsql://127.0.0.1:{hrana_port}")
+                click.echo(f"   HTTP API: http://127.0.0.1:{http_port}")
                 click.echo(f"   Log file: {os.path.abspath('sqld.log')}")
 
         except FileNotFoundError:
@@ -417,7 +423,7 @@ def serve(
         click.echo(f"   Working directory: {os.getcwd()}")
         click.echo("")
         click.echo("🔄 Starting services...")
-        click.echo(f"   - sqld daemon: http://127.0.0.1:{sqld_port}")
+        click.echo(f"   - sqld daemon: libsql://127.0.0.1:{sqld_port} (HTTP API: http://127.0.0.1:{sqld_port + 1})")
         click.echo(f"   - Environment service: http://127.0.0.1:{env_port}")
         click.echo("")
         click.echo("💡 Tips:")

synth_ai/cli/lib/__init__.py

@@ -0,0 +1,10 @@
+"""
+Support utilities reused across CLI subcommands.
+
+This module currently exposes helpers for env handling and discovery by
+re-exporting the maintained implementations under ``synth_ai.utils``.
+"""
+
+from __future__ import annotations
+
+from .task_app_env import *  # noqa: F401,F403

synth_ai/cli/lib/task_app_discovery.py

@@ -0,0 +1,7 @@
+"""
+Backwards-compatible re-export of task app discovery helpers.
+"""
+
+from __future__ import annotations
+
+from synth_ai.utils.task_app_discovery import *  # noqa: F401,F403