synth-ai 0.2.8.dev12__py3-none-any.whl → 0.2.9.dev0__py3-none-any.whl

synth_ai/demo_registry.py

@@ -0,0 +1,258 @@
+"""Registry of demo task app templates for `uvx synth-ai demo init`."""
+
+from __future__ import annotations
+
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Iterable
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+
+
+@dataclass(frozen=True)
+class CopySpec:
+    """File copy specification from repo-relative source to template-relative destination."""
+
+    source: str
+    destination: str
+    make_executable: bool = False
+
+    def absolute_source(self) -> Path:
+        return (REPO_ROOT / self.source).resolve()
+
+
+@dataclass(frozen=True)
+class DemoTemplate:
+    """Describes a demo task app template that can be materialised into the CWD."""
+
+    template_id: str
+    name: str
+    description: str
+    copy_specs: tuple[CopySpec, ...]
+    default_subdir: str | None = None
+    env_lines: tuple[str, ...] = ()
+    config_source: str | None = None
+    config_destination: str = "demo_config.toml"
+    requires_modal: bool = False
+    post_copy: Callable[[Path], None] | None = None
+
+    def iter_copy_specs(self) -> Iterable[CopySpec]:
+        return self.copy_specs
+
+    def config_source_path(self) -> Path | None:
+        if not self.config_source:
+            return None
+        return (REPO_ROOT / self.config_source).resolve()
+
+
+DEMO_TEMPLATES: tuple[DemoTemplate, ...] = (
+    DemoTemplate(
+        template_id="math-modal",
+        name="Math Single-Step (Modal deployment)",
+        description="Packaged modal task app matching examples/rl math environment.",
+        copy_specs=(
+            CopySpec(
+                "synth_ai/demos/demo_task_apps/math/modal_task_app.py",
+                "task_app.py",
+            ),
+            CopySpec(
+                "synth_ai/demos/demo_task_apps/math/deploy_task_app.sh",
+                "deploy_task_app.sh",
+                make_executable=True,
+            ),
+            CopySpec(
+                "examples/rl/configs/rl_from_base_qwen17.toml",
+                "configs/rl_from_base_qwen17.toml",
+            ),
+        ),
+        default_subdir="math_demo",
+        env_lines=(
+            "# Required for task app auth to environment service",
+            "ENVIRONMENT_API_KEY=",
+            "",
+            "# Optional: for CLI job submission and proxying OpenAI models",
+            "SYNTH_API_KEY=",
+            "OPENAI_API_KEY=",
+            "",
+            "# Optional: set to 'prod' to use production names",
+            "ENVIRONMENT=",
+        ),
+        config_source="examples/rl/configs/rl_from_base_qwen17.toml",
+        requires_modal=True,
+        post_copy=lambda root: _postprocess_math_modal(root),
+    ),
+    DemoTemplate(
+        template_id="crafter-local",
+        name="Crafter GRPO (local FastAPI)",
+        description="Lightweight wrapper around synth_ai.task.apps.grpo_crafter for local experimentation.",
+        copy_specs=(
+            CopySpec(
+                "examples/warming_up_to_rl/task_app/grpo_crafter_task_app.py",
+                "task_app.py",
+            ),
+            CopySpec(
+                "examples/warming_up_to_rl/task_app/README.md",
+                "README.md",
+            ),
+            CopySpec(
+                "examples/warming_up_to_rl/configs/rl_from_base_qwen4b.toml",
+                "configs/rl_from_base_qwen4b.toml",
+            ),
+            CopySpec(
+                "examples/warming_up_to_rl/configs/crafter_fft_4b.toml",
+                "configs/crafter_fft_4b.toml",
+            ),
+        ),
+        default_subdir="crafter_demo",
+        env_lines=(
+            "ENVIRONMENT_API_KEY=",
+            "SYNTH_API_KEY=",
+            "",
+            "# Optional: URL for existing Crafter task app",
+            "TASK_APP_BASE_URL=",
+        ),
+        config_source="examples/warming_up_to_rl/configs/rl_from_base_qwen4b.toml",
+        config_destination="demo_config.toml",
+        requires_modal=False,
+        post_copy=lambda root: _postprocess_crafter_local(root),
+    ),
+)
+
+
+def get_demo_template(template_id: str) -> DemoTemplate | None:
+    for template in DEMO_TEMPLATES:
+        if template.template_id == template_id:
+            return template
+    return None
+
+
+def list_demo_templates() -> tuple[DemoTemplate, ...]:
+    return DEMO_TEMPLATES
+
+
+def _postprocess_math_modal(root: Path) -> None:
+    task_path = (root / "task_app.py").resolve()
+    if not task_path.exists():
+        return
+    text = task_path.read_text(encoding="utf-8")
+    text = text.replace('App("hendrycks-math-task-app")', 'App("hendrycks-math-task-app-demo")')
+    text = text.replace('DEFAULT_TASK_APP_SECRET_NAME = "hendrycks-math-task-app-secret"', 'DEFAULT_TASK_APP_SECRET_NAME = "hendrycks-math-task-app-demo-secret"')
+    task_path.write_text(text, encoding="utf-8")
+
+
+CRAFT_DEMO_TEMPLATE = textwrap.dedent(
+    '''
+"""Demo-friendly wrapper for the GRPO Crafter task app."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from synth_ai.task.apps import ModalDeploymentConfig, registry
+from synth_ai.task.apps.grpo_crafter import build_config
+from synth_ai.task.server import TaskAppConfig, create_task_app, run_task_app
+
+
+APP_ID = "grpo-crafter-demo"
+BASE_APP_ID = "grpo-crafter"
+
+
+_BASE_CONFIG = build_config()
+TASK_APP_CONFIG = TaskAppConfig(
+    app_id="grpo-crafter-demo",
+    name=_BASE_CONFIG.name,
+    description=_BASE_CONFIG.description,
+    base_task_info=_BASE_CONFIG.base_task_info,
+    describe_taskset=_BASE_CONFIG.describe_taskset,
+    provide_task_instances=_BASE_CONFIG.provide_task_instances,
+    rollout=_BASE_CONFIG.rollout,
+    dataset_registry=_BASE_CONFIG.dataset_registry,
+    rubrics=_BASE_CONFIG.rubrics,
+    proxy=_BASE_CONFIG.proxy,
+    routers=_BASE_CONFIG.routers,
+    middleware=_BASE_CONFIG.middleware,
+    app_state=_BASE_CONFIG.app_state,
+    require_api_key=_BASE_CONFIG.require_api_key,
+    expose_debug_env=_BASE_CONFIG.expose_debug_env,
+    cors_origins=_BASE_CONFIG.cors_origins,
+    startup_hooks=_BASE_CONFIG.startup_hooks,
+    shutdown_hooks=_BASE_CONFIG.shutdown_hooks,
+)
+
+try:
+    _BASE_ENTRY = registry.get(BASE_APP_ID)
+except Exception:  # pragma: no cover - registry may be unavailable
+    MODAL_DEPLOYMENT: ModalDeploymentConfig | None = None
+else:
+    base_modal = _BASE_ENTRY.modal
+    if base_modal is None:
+        MODAL_DEPLOYMENT = None
+    else:
+        modal_app_name = base_modal.app_name
+        if not modal_app_name.endswith("-demo"):
+            modal_app_name = f"{modal_app_name}-demo"
+        MODAL_DEPLOYMENT = ModalDeploymentConfig(
+            app_name=modal_app_name,
+            python_version=base_modal.python_version,
+            pip_packages=tuple(base_modal.pip_packages),
+            extra_local_dirs=tuple(base_modal.extra_local_dirs),
+            secret_names=tuple(base_modal.secret_names),
+            volume_mounts=tuple(base_modal.volume_mounts),
+            timeout=base_modal.timeout,
+            memory=base_modal.memory,
+            cpu=base_modal.cpu,
+            min_containers=base_modal.min_containers,
+            max_containers=base_modal.max_containers,
+        )
+
+ENV_FILES: tuple[str, ...] = ()
+
+
+def build_task_app_config() -> TaskAppConfig:
+    """Return a fresh TaskAppConfig for the demo wrapper."""
+
+    return TASK_APP_CONFIG.clone()
+
+
+def fastapi_app():
+    """Return the FastAPI application for Modal or other ASGI hosts."""
+
+    return create_task_app(build_task_app_config())
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run the Crafter task app locally")
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=8001)
+    parser.add_argument("--reload", action="store_true", help="Enable uvicorn autoreload")
+    parser.add_argument(
+        "--env-file",
+        action="append",
+        default=[],
+        help="Additional .env files to load before startup",
+    )
+    args = parser.parse_args()
+
+    default_env = Path(__file__).resolve().parents[4] / "backend" / ".env.dev"
+    env_files = [str(default_env)] if default_env.exists() else []
+    env_files.extend(args.env_file or [])
+
+    run_task_app(
+        build_task_app_config,
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        env_files=env_files,
+    )
+    '''
+).strip() + "\n"
+
+
+def _postprocess_crafter_local(root: Path) -> None:
+    task_path = (root / "task_app.py").resolve()
+    if not task_path.exists():
+        return
+    task_path.write_text(CRAFT_DEMO_TEMPLATE, encoding="utf-8")
+

synth_ai/demos/core/cli.py

@@ -12,8 +12,14 @@ import stat
 import textwrap
 
 from synth_ai.demos.demo_task_apps import core as demo_core
-from synth_ai.handshake import run_handshake, HandshakeError
 from synth_ai.demos.demo_task_apps.core import DemoEnv, DEFAULT_TASK_APP_SECRET_NAME
+from synth_ai.demo_registry import (
+    CopySpec,
+    DemoTemplate,
+    get_demo_template,
+    list_demo_templates,
+)
+from synth_ai.handshake import run_handshake, HandshakeError
 
 
 def _key_preview(value: str, label: str) -> str:
@@ -912,125 +918,153 @@ def cmd_deploy(args: argparse.Namespace) -> int:
     return 0
 
 
-def cmd_init(args: argparse.Namespace) -> int:
-    """Initialize a Modal-ready Math Task App in the current directory.
+def _ensure_modal_installed() -> None:
+    """Install the modal package if it is not already available."""
 
-    Copies `examples/rl/task_app.py` and `examples/rl/deploy_task_app.sh` into CWD.
-    Creates a `.env` with placeholders if it does not exist.
-    """
     try:
-        # Ensure `modal` is installed for deployment flows
-        def _has_modal() -> bool:
-            try:
-                import importlib.util as _iu
-                return _iu.find_spec("modal") is not None
-            except Exception:
-                return False
+        import importlib.util as _iu
 
-        if not _has_modal():
-            print("modal not found; installing…")
-            # Prefer uv if available; otherwise fallback to pip
-            try:
-                if shutil.which("uv"):
-                    code, out = _popen_capture(["uv", "pip", "install", "modal>=1.1.4"])
-                else:
-                    code, out = _popen_capture([sys.executable, "-m", "pip", "install", "modal>=1.1.4"])
-                if code != 0:
-                    print(out)
-                    print("Failed to install modal; continuing may fail.")
-                else:
-                    print("modal installed successfully.")
-            except Exception as e:
-                print(f"modal install error: {e}")
-            # Re-check
-            if not _has_modal():
-                print("Warning: modal is still not importable after install attempt.")
+        if _iu.find_spec("modal") is not None:
+            print("modal package found")
+            return
+    except Exception:
+        pass
+
+    print("modal not found; installing…")
+    try:
+        if shutil.which("uv"):
+            code, out = _popen_capture(["uv", "pip", "install", "modal>=1.1.4"])
         else:
-            print("modal found")
-
-        here = os.getcwd()
-        demo_dir = os.path.join(here, "synth_demo")
-        os.makedirs(demo_dir, exist_ok=True)
-        # Paths inside synth_demo/
-        dst_task_py = os.path.join(demo_dir, "task_app.py")
-        dst_deploy = os.path.join(demo_dir, "deploy_task_app.sh")
-        env_path = os.path.join(demo_dir, ".env")
-        dst_cfg = os.path.join(demo_dir, "demo_config.toml")
-
-        # Copy packaged math modal task app into synth_demo/task_app.py
-        src_modal = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "demo_task_apps", "math", "modal_task_app.py"))
-        if not os.path.isfile(src_modal):
-            print("Init failed: packaged math modal task app not found.")
-            print(f"Looked for: {src_modal}")
-            return 1
-        if os.path.exists(dst_task_py) and not getattr(args, "force", False):
-            print(f"Refusing to overwrite existing file: {dst_task_py} (use --force)")
+            code, out = _popen_capture([sys.executable, "-m", "pip", "install", "modal>=1.1.4"])
+        if code != 0:
+            print(out)
+            print("Failed to install modal; continuing may fail.")
+        else:
+            print("modal installed successfully.")
+    except Exception as exc:
+        print(f"modal install error: {exc}")
+
+    try:
+        import importlib.util as _iu
+
+        if _iu.find_spec("modal") is None:
+            print("Warning: modal is still not importable after install attempt.")
+        else:
+            print("modal package ready")
+    except Exception:
+        print("Warning: unable to verify modal installation.")
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    """Materialise a demo task app template into the current directory."""
+
+    templates = list(list_demo_templates())
+    if not templates:
+        print("No demo templates registered. Update synth_ai/demo_registry.py to add entries.")
+        return 1
+
+    selected: DemoTemplate | None = None
+    if args.template:
+        selected = get_demo_template(args.template)
+        if selected is None:
+            available = ", ".join(t.template_id for t in templates)
+            print(f"Unknown template '{args.template}'. Available: {available}")
             return 1
-        shutil.copy2(src_modal, dst_task_py)
-
-        # Create deploy script in synth_demo/
-        deploy_text = r"""#!/usr/bin/env bash
-set -euo pipefail
-
-HERE=$(cd "$(dirname "$0")" && pwd)
-APP="$HERE/task_app.py"
-if [ -f "$HERE/.env" ]; then
-  # shellcheck disable=SC2046
-  export $(grep -v '^#' "$HERE/.env" | xargs -I{} echo {})
-fi
-uv run modal deploy "$APP" | tee "$HERE/.last_deploy.log"
-URL=$(grep -Eo 'https://[^ ]+\.modal\.run' "$HERE/.last_deploy.log" | tail -1 || true)
-if [ -n "$URL" ]; then
-  if grep -q '^TASK_APP_BASE_URL=' "$HERE/.env" 2>/dev/null; then
-    sed -i.bak "s#^TASK_APP_BASE_URL=.*#TASK_APP_BASE_URL=$URL#" "$HERE/.env" || true
-  else
-    echo "TASK_APP_BASE_URL=$URL" >> "$HERE/.env"
-  fi
-  echo "Saved TASK_APP_BASE_URL to $HERE/.env"
-fi
-"""
-        _write_text(dst_deploy, deploy_text)
+    else:
+        print("Select a demo template:" + "\n")
+        for idx, template in enumerate(templates, start=1):
+            print(f"  [{idx}] {template.name} ({template.template_id})")
+            print(f"      {template.description}")
         try:
-            st = os.stat(dst_deploy)
-            os.chmod(dst_deploy, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+            choice_raw = input(f"Enter choice [1-{len(templates)}] (default 1): ").strip() or "1"
         except Exception:
-            pass
+            choice_raw = "1"
+        if not choice_raw.isdigit():
+            print("Selection must be a number.")
+            return 1
+        choice_idx = int(choice_raw)
+        if not 1 <= choice_idx <= len(templates):
+            print("Selection out of range.")
+            return 1
+        selected = templates[choice_idx - 1]
 
-        # Seed .env if not present
-        if not os.path.exists(env_path):
-            _write_text(env_path, "\n".join([
-                "# Required for task app auth to environment service",
-                "ENVIRONMENT_API_KEY=",
-                "",
-                "# Optional: for CLI job submission and proxying OpenAI models",
-                "SYNTH_API_KEY=",
-                "OPENAI_API_KEY=",
-                "",
-                "# Optional: set to 'prod' to use production names",
-                "ENVIRONMENT=",
-            ]) + "\n")
-
-        # Seed demo_config.toml from packaged default if not present (or overwrite with --force)
-        packaged_cfg = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "demo_task_apps", "math", "config.toml"))
-        try:
-            if os.path.isfile(packaged_cfg):
-                if not os.path.exists(dst_cfg) or getattr(args, "force", False):
-                    shutil.copy2(packaged_cfg, dst_cfg)
-        except Exception:
-            pass
+    assert selected is not None
+
+    default_subdir = selected.default_subdir or selected.template_id
+    default_dest = Path(args.dest).expanduser().resolve() if args.dest else (Path.cwd() / default_subdir).resolve()
+    try:
+        dest_input = input(f"Destination directory [{default_dest}]: ").strip()
+    except Exception:
+        dest_input = ""
+    destination = Path(dest_input).expanduser().resolve() if dest_input else default_dest
+
+    if destination.exists():
+        if destination.is_file():
+            print(f"Destination {destination} is a file. Provide a directory path.")
+            return 1
+        if not args.force and any(destination.iterdir()):
+            print(f"Destination {destination} is not empty. Use --force or choose another directory.")
+            return 1
+    else:
+        destination.mkdir(parents=True, exist_ok=True)
 
-        print("Initialized Math Task App in synth_demo/:")
-        print(f"  - {dst_task_py}")
-        print(f"  - {dst_deploy}")
-        print(f"  - {env_path} (created if missing)")
-        if os.path.exists(dst_cfg):
-            print(f"  - {dst_cfg} (seeded)")
-        print("")
-        print("\nNext step:\n$ uvx synth-ai setup")
+    if selected.requires_modal:
+        _ensure_modal_installed()
+
+    try:
+        for spec in selected.iter_copy_specs():
+            src_path = spec.absolute_source()
+            if not src_path.exists():
+                print(f"Template source missing: {src_path}")
+                return 1
+            dest_path = (destination / spec.destination).resolve()
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            if dest_path.exists() and not args.force:
+                print(f"Refusing to overwrite existing file: {dest_path} (use --force)")
+                return 1
+            shutil.copy2(src_path, dest_path)
+            if spec.make_executable:
+                try:
+                    st = os.stat(dest_path)
+                    os.chmod(dest_path, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+                except Exception:
+                    pass
+
+        if selected.env_lines:
+            env_path = destination / ".env"
+            if not env_path.exists() or args.force:
+                _write_text(env_path, "\n".join(selected.env_lines) + "\n")
+
+        config_src = selected.config_source_path()
+        if config_src and config_src.exists():
+            cfg_dst = (destination / selected.config_destination).resolve()
+            if not cfg_dst.exists() or args.force:
+                cfg_dst.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(config_src, cfg_dst)
+
+        if selected.post_copy is not None:
+            try:
+                selected.post_copy(destination)
+            except Exception as post_exc:
+                print(f"Post-processing failed: {post_exc}")
+                return 1
+
+        print(f"Demo template '{selected.name}' materialised at {destination}.")
+        print("Files created:")
+        for spec in selected.iter_copy_specs():
+            print(f"  - {spec.destination}")
+        if selected.env_lines:
+            print("  - .env")
+        if selected.config_source_path():
+            print(f"  - {selected.config_destination}")
+        print("Review the files, edit .env, and run any provided deploy scripts when ready.")
         return 0
-    except Exception as e:
-        print(f"Init error: {e}")
-        return 2
+    except KeyboardInterrupt:
+        print("Aborted")
+        return 1
+    except Exception as exc:
+        print(f"Init failed: {exc}")
+        return 1
 
 
 def _http(method: str, url: str, headers: Dict[str, str] | None = None, body: Dict[str, Any] | None = None) -> tuple[int, Dict[str, Any] | str]:
@@ -1358,7 +1392,9 @@ def main(argv: list[str] | None = None) -> int:
     _add_parser(["rl_demo.setup", "demo.setup"], configure=lambda parser: parser.set_defaults(func=cmd_setup))
 
     def _init_opts(parser):
-        parser.add_argument("--force", action="store_true", help="Overwrite existing files in CWD")
+        parser.add_argument("--template", type=str, default=None, help="Template id to instantiate")
+        parser.add_argument("--dest", type=str, default=None, help="Destination directory for files")
+        parser.add_argument("--force", action="store_true", help="Overwrite existing files in destination")
         parser.set_defaults(func=cmd_init)
 
     _add_parser(["rl_demo.init", "demo.init"], configure=_init_opts)

synth_ai/demos/demo_task_apps/__init__.py

@@ -1 +1,7 @@
-# Namespace for demo task apps (math, etc.)
+"""Namespace for demo task apps (math, etc.)."""
+
+# Ensure registry entries are loaded for CLI discovery.
+try:  # pragma: no cover - optional on downstream installs
+    from .math import task_app_entry  # noqa: F401
+except Exception:
+    pass