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

synth_ai/auth/credentials.py

@@ -0,0 +1,119 @@
+import contextlib
+import os
+import time
+import webbrowser
+
+import requests
+from requests import RequestException
+from synth_ai.utils.env import resolve_env_var, write_env_var_to_dotenv, write_env_var_to_json
+
+
+def fetch_credentials_from_web_browser_session(
+    browser: bool = True,
+    prod: bool = True
+) -> None:
+    synth_api_key = ''
+    env_api_key = ''
+    org_name = ''
+
+    if browser:
+        origin = "https://www.usesynth.ai" if prod else "http://localhost:3000"
+        init_url = f"{origin}/api/sdk/handshake/init"
+        token_url =f"{origin}/api/sdk/handshake/token"
+
+        print(f"\n🌐 Connecting to {origin} to fetch your Synth credentials")
+
+        # 1. Initialize browser handshake
+        try:
+            init_res = requests.post(init_url, timeout=10)
+        except RequestException as exc:
+            raise RuntimeError(f"Failed to reach handshake init endpoint: {exc}") from exc
+
+        if init_res.status_code != 200:
+            body = init_res.text.strip()
+            raise RuntimeError(f"Handshake init failed ({init_res.status_code}): {body or 'no response body'}")
+
+        try:
+            init_data = init_res.json()
+        except ValueError as exc:
+            raise RuntimeError("Handshake init returned malformed JSON.") from exc
+
+        device_code = str(init_data.get("device_code") or "").strip()
+        verification_uri = str(init_data.get("verification_uri") or "").strip()
+        if not device_code or not verification_uri:
+            raise RuntimeError("Handshake init response missing device_code or verification_uri.")
+
+        try:
+            expires_in = int(init_data.get("expires_in") or 600)
+        except (TypeError, ValueError):
+            expires_in = 120
+        try:
+            interval = max(int(init_data.get("interval") or 3), 1)
+        except (TypeError, ValueError):
+            interval = 3
+
+        # 2. Open browser to verification URL
+        with contextlib.suppress(Exception):
+            webbrowser.open(verification_uri)
+
+        deadline = time.time() + expires_in
+        handshake_data = None
+
+        # 3. Poll handshake token endpoint
+        while time.time() <= deadline:
+            try:
+                handshake_res = requests.post(
+                    token_url,
+                    json={"device_code": device_code},
+                    timeout=10,
+                )
+            except RequestException:
+                time.sleep(interval)
+                continue
+
+            if handshake_res.status_code == 200:
+                try:
+                    handshake_data = handshake_res.json()
+                except ValueError as exc:
+                    raise RuntimeError("Handshake token returned malformed JSON.") from exc
+                break
+
+            if handshake_res.status_code in (404, 410):
+                raise RuntimeError("Handshake failed: device code expired or was revoked.")
+
+            time.sleep(interval)
+
+        if handshake_data is None:
+            raise TimeoutError("Handshake timed out before credentials were returned.")
+
+        # 4. Extract credentials from handshake payload
+        org = handshake_data.get("org")
+        if not isinstance(org, dict):
+            org = {}
+        org_name = str(org.get("name") or "your organization").strip()
+
+        credentials = handshake_data.get("keys")
+        if not isinstance(credentials, dict):
+            credentials = {}
+
+        synth_api_key = str(credentials.get("synth") or "").strip()
+        env_api_key = str(credentials.get("rl_env") or "").strip()
+
+        print(f"\n✅ Connected to {org_name}")
+
+    # Load credentials to process environment and save credentials to .env and ~/synth-ai/config.json
+    if synth_api_key:
+        print("\nLoading SYNTH_API_KEY into process environment")
+        os.environ["SYNTH_API_KEY"] = synth_api_key
+    synth_api_key = resolve_env_var("SYNTH_API_KEY")
+    if env_api_key:
+        print("\nLoading ENVIRONMENT_API_KEY into process environment")
+        os.environ["ENVIRONMENT_API_KEY"] = env_api_key
+    env_api_key = resolve_env_var("ENVIRONMENT_API_KEY")
+
+    if browser:
+        print('')
+        write_env_var_to_json("SYNTH_API_KEY", synth_api_key, "~/.synth-ai/config.json")
+        write_env_var_to_dotenv("SYNTH_API_KEY", synth_api_key)
+        write_env_var_to_json("ENVIRONMENT_API_KEY", env_api_key, "~/.synth-ai/config.json")
+        write_env_var_to_dotenv("ENVIRONMENT_API_KEY", env_api_key)

synth_ai/cli/__init__.py

@@ -8,8 +8,9 @@ pyproject entry point `synth_ai.cli:cli`.
 from __future__ import annotations
 
 import importlib
+import sys
 from collections.abc import Callable
-from typing import Any, cast
+from typing import Any
 
 # Load environment variables from a local .env if present (repo root)
 try:
@@ -21,86 +22,77 @@ except Exception:
     # dotenv is optional at runtime; proceed if unavailable
     pass
 
-try:
-    from synth_ai.cli._typer_patch import patch_typer_make_metavar
-
-    patch_typer_make_metavar()
-except Exception:
-    pass
+def _callable_from(module: Any, attr: str) -> Callable[..., Any] | None:
+    candidate = getattr(module, attr, None)
+    return candidate if callable(candidate) else None
 
 
-from synth_ai.cli.root import cli  # new canonical CLI entrypoint
+def _maybe_import(module_path: str) -> Any | None:
+    try:
+        return importlib.import_module(module_path)
+    except Exception:
+        return None
 
-# Register subcommands from this package onto the group
-# Deprecated/legacy commands intentionally not registered: watch/experiments, balance, calc,
-# man, recent, status, traces
-try:
-    from synth_ai.cli import demo as _demo
 
-    _demo.register(cli)
-except Exception:
-    pass
-try:
-    from synth_ai.cli import turso as _turso
+def _maybe_call(module_path: str, attr: str, *args: Any, **kwargs: Any) -> None:
+    module = _maybe_import(module_path)
+    if not module:
+        return
+    fn = _callable_from(module, attr)
+    if fn:
+        fn(*args, **kwargs)
 
-    _turso.register(cli)
-except Exception:
-    pass
-try:
-    _train_module = cast(Any, importlib.import_module("synth_ai.api.train"))
-    _train_register = cast(Callable[[Any], None], _train_module.register)
-    _train_register(cli)
-except Exception:
-    pass
 
+# Apply Typer patch if available
+_maybe_call("synth_ai.cli._typer_patch", "patch_typer_make_metavar")
 
-# Import task_app_group conditionally
-try:
-    from synth_ai.cli.task_apps import task_app_group
-    cli.add_command(task_app_group, name="task-app")
-except Exception:
-    # Task app functionality not available
-    pass
 
+_cli_module = _maybe_import("synth_ai.cli.root")
+if not _cli_module:
+    raise ImportError("synth_ai.cli.root is required for CLI entrypoint")
+cli = _cli_module.cli  # type: ignore[attr-defined]
 
+# Register core commands implemented as standalone modules
 try:
-    # Make task_apps import more robust to handle missing optional dependencies
-    import importlib
-    task_apps_module = importlib.import_module('synth_ai.cli.task_apps')
-    task_apps_module.register(cli)
-except (ImportError, ModuleNotFoundError, TypeError, RuntimeError) as e:
-    # Task apps module not available (missing optional dependencies)
-    # This is expected - silently skip
-    pass
-
-# Register TUI command - make import completely isolated
-def _register_tui_command():
-    """Register TUI command only when called, not during CLI startup."""
-    try:
-        # Import TUI only when the command is actually used
-        from synth_ai.cli.tui import register as tui_register
-        tui_register(cli)
-    except Exception:
-        # TUI not available - this is expected if dependencies are missing
-        pass
+    from synth_ai.cli.setup import setup_cmd
 
-# Add TUI command as a lazy-registered command
-try:
-    # Try to import and register immediately for normal cases
-    from synth_ai.cli.tui import register as tui_register
-    tui_register(cli)
+    cli.add_command(setup_cmd, name="setup")
 except Exception:
-    # If that fails, add a lazy registration that will only happen when called
-    # For now, just skip - the command won't be available but CLI won't crash
     pass
 
-# Add task app commands if available
-try:
-    if 'task_app_group' in locals() and hasattr(task_app_group, 'commands'):
-        cli.add_command(task_app_group.commands["serve"], name="serve")
-        cli.add_command(task_app_group.commands["deploy"], name="deploy")
-        cli.add_command(task_app_group.commands["modal-serve"], name="modal-serve")
-except Exception:
-    # Task app commands not available
-    pass
+
+# Register optional subcommands packaged under synth_ai.cli.*
+for _module_path in ("synth_ai.cli.commands.demo", "synth_ai.cli.commands.status", "synth_ai.cli.turso"):
+    module = _maybe_import(_module_path)
+    if not module:
+        continue
+    sub_name = _module_path.rsplit(".", 1)[-1]
+    setattr(sys.modules[__name__], sub_name, module)
+    fn = _callable_from(module, "register")
+    if fn:
+        fn(cli)
+
+# Register help command
+_maybe_call("synth_ai.cli.commands.help.core", "register", cli)
+
+# Train CLI lives under synth_ai.api.train
+_maybe_call("synth_ai.api.train", "register", cli)
+
+# Task app group/commands are optional and have richer API surface
+_task_apps_module = _maybe_import("synth_ai.cli.task_apps")
+if _task_apps_module:
+    task_app_group = getattr(_task_apps_module, "task_app_group", None)
+    if task_app_group is not None:
+        cli.add_command(task_app_group, name="task-app")
+        # Expose common aliases when present
+        commands = getattr(task_app_group, "commands", None)
+        if isinstance(commands, dict):
+            for alias, name in (("serve", "serve"), ("deploy", "deploy"), ("modal-serve", "modal-serve")):
+                command = commands.get(name)
+                if command is not None:
+                    cli.add_command(command, name=alias)
+    register_task_apps = _callable_from(_task_apps_module, "register")
+    if register_task_apps:
+        register_task_apps(cli)
+
 # Top-level 'info' alias removed; use `synth-ai task-app info` instead

synth_ai/cli/_modal_wrapper.py

@@ -1,16 +1,19 @@
 from __future__ import annotations
 
+import importlib
 import sys
 
 
 def main() -> int:
     # Apply Typer compatibility patch before Modal CLI bootstraps Click/Typer internals.
     try:
-        from synth_ai.cli._typer_patch import patch_typer_make_metavar
-
-        patch_typer_make_metavar()
+        module = importlib.import_module("synth_ai.cli._typer_patch")
     except Exception:
-        pass
+        module = None
+    if module is not None:
+        patch = getattr(module, "patch_typer_make_metavar", None)
+        if callable(patch):
+            patch()
 
     from modal.__main__ import main as modal_main
 
@@ -26,4 +29,3 @@ def main() -> int:
 
 if __name__ == "__main__":
     sys.exit(main())
-

synth_ai/cli/_typer_patch.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from click import Parameter
 
 

synth_ai/cli/_validate_task_app.py

@@ -3,9 +3,27 @@
 # This module provides the validate_task_app function for CLI use
 # The actual implementation is imported from the task module
 
-from synth_ai.task.validators import (
-    validate_task_app_endpoint as validate_task_app,  # type: ignore[attr-defined]
-)
+import importlib
+from collections.abc import Callable
+from typing import Any
 
-__all__ = ["validate_task_app"]
+_validators_module: Any | None = None
+validate_task_app: Callable[..., Any] | None = None
+
+try:
+    _validators_module = importlib.import_module("synth_ai.task.validators")
+except Exception:
+    _validators_module = None
+
+if _validators_module is not None:
+    candidate = getattr(_validators_module, "validate_task_app_endpoint", None)
+    if callable(candidate):
+        validate_task_app = candidate
 
+if validate_task_app is None:
+    def _missing_validate_task_app(*_args: Any, **_kwargs: Any) -> None:
+        raise RuntimeError("task validation utilities are unavailable in this environment")
+
+    validate_task_app = _missing_validate_task_app
+
+__all__ = ["validate_task_app"]

synth_ai/cli/commands/__init__.py

@@ -0,0 +1,17 @@
+"""
+Structured CLI command implementations.
+
+Each subpackage under this namespace provides the core command entrypoints,
+validation helpers, and error types for a top-level CLI command (e.g. train,
+eval, deploy).
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "train",
+    "eval",
+    "filter",
+    "deploy",
+    "status",
+]

synth_ai/cli/commands/demo/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .core import command, register
+
+__all__ = ["command", "register"]
+

synth_ai/cli/commands/demo/core.py

@@ -0,0 +1,163 @@
+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
+
+__all__ = ["command", "register"]
+
+_demo_cli = 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(path for path in root.rglob("run_demo.sh") if path.is_file())
+
+
+def _run_demo_command(func: Any, *args: Any, **kwargs: Any) -> None:
+    """Invoke a demo command and map non-zero exits to Click exits."""
+
+    try:
+        result = func(*args, **kwargs)
+    except SystemExit as exc:  # pragma: no cover - defensive shim
+        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)
+
+
+@click.group(
+    "demo",
+    invoke_without_command=True,
+    help="Demo helpers for the math RL pipeline.",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Overwrite existing files in the current directory when initializing demo assets.",
+)
+@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 command(ctx: click.Context, force: bool, list_only: bool, filter_term: str) -> None:
+    """Default command: initialize RL demo files into ./synth_demo/ (alias of `demo init`)."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    if list_only:
+        repo_root = Path(os.getcwd())
+        examples_dir = repo_root / "examples"
+        demos = _find_demo_scripts(examples_dir)
+        if filter_term:
+            term = filter_term.lower()
+            demos = [path for path in demos if term in str(path).lower()]
+
+        if not demos:
+            click.echo("No run_demo.sh scripts found under examples/.")
+            return
+
+        click.echo("Available demos:")
+        for idx, path in enumerate(demos, start=1):
+            click.echo(f" {idx}. {path.relative_to(repo_root)}")
+        click.echo("")
+
+        def _validate_choice(val: str) -> int:
+            try:
+                selection = int(val)
+            except Exception as err:  # pragma: no cover - Click handles prompt errors
+                raise click.BadParameter("Enter a number from the list") from err
+            if selection < 1 or selection > len(demos):
+                raise click.BadParameter(f"Choose a number between 1 and {len(demos)}")
+            return selection
+
+        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 exc:
+            click.echo(f"❌ Demo exited with non-zero status: {exc.returncode}")
+        except KeyboardInterrupt:
+            click.echo("\n🛑 Demo interrupted by user")
+        return
+
+    _run_demo_command(_demo_cli.init, force=force)
+
+
+@command.command("deploy")
+@click.option("--local", is_flag=True, help="Run the local FastAPI app instead of deploying to Modal.")
+@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 helper).",
+)
+def demo_deploy(local: bool, app: str | None, name: str, script: str | None) -> None:
+    _run_demo_command(
+        _demo_cli.deploy,
+        local=local,
+        app=app,
+        name=name,
+        script=script,
+    )
+
+
+@command.command("configure")
+def demo_configure() -> None:
+    _run_demo_command(_demo_cli.run)
+
+
+@command.command("setup")
+def demo_setup() -> None:
+    _run_demo_command(_demo_cli.setup)
+
+
+@command.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,
+) -> None:
+    _run_demo_command(
+        _demo_cli.run,
+        batch_size=batch_size,
+        group_size=group_size,
+        model=model,
+        timeout=timeout,
+    )
+
+
+@click.command("setup")
+def setup_alias() -> None:
+    """Perform SDK handshake and write keys to .env."""
+    _run_demo_command(_demo_cli.setup)
+
+
+def register(cli: click.Group) -> None:
+    """Attach the demo command group and related aliases to the CLI."""
+    cli.add_command(command)
+    cli.add_command(setup_alias)
+

synth_ai/cli/commands/deploy/__init__.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from .core import (
+    command,
+    get_command,
+    modal_serve_command,
+    register_task_app_commands,
+    run_modal_runtime,
+    run_uvicorn_runtime,
+)
+from .errors import DeployCliError
+from .validation import validate_deploy_options
+
+__all__ = [
+    "command",
+    "get_command",
+    "modal_serve_command",
+    "register_task_app_commands",
+    "run_modal_runtime",
+    "run_uvicorn_runtime",
+    "DeployCliError",
+    "validate_deploy_options",
+]