synth-ai 0.2.9.dev5__py3-none-any.whl → 0.2.10__py3-none-any.whl

synth_ai/demos/demo_task_apps/__init__.py

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

synth_ai/demos/demo_task_apps/core.py

@@ -3,15 +3,12 @@ from __future__ import annotations
 import json
 import os
 import subprocess
-import sys
-from dataclasses import dataclass
-from typing import Any, Dict, Optional, Tuple
-
 import urllib.request
+from dataclasses import dataclass
+from typing import Any
 
 from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT
 
-
 DEFAULT_TASK_APP_SECRET_NAME = "hendrycks-math-task-app-secret"
 
 
@@ -24,6 +21,7 @@ class DemoEnv:
     task_app_name: str = ""
     task_app_secret_name: str = DEFAULT_TASK_APP_SECRET_NAME
 
+
 def _mask(value: str, keep: int = 4) -> str:
     if not value:
         return ""
@@ -34,7 +32,7 @@ def _state_path() -> str:
     return os.path.expanduser("~/.synth-ai/demo.json")
 
 
-def _read_state() -> Dict[str, Any]:
+def _read_state() -> dict[str, Any]:
     try:
         path = _state_path()
         if os.path.isfile(path):
@@ -46,7 +44,7 @@ def _read_state() -> Dict[str, Any]:
     return {}
 
 
-def _write_state(data: Dict[str, Any]) -> None:
+def _write_state(data: dict[str, Any]) -> None:
     try:
         path = _state_path()
         os.makedirs(os.path.dirname(path), exist_ok=True)
@@ -56,8 +54,8 @@ def _write_state(data: Dict[str, Any]) -> None:
         pass
 
 
-def load_dotenv_file(path: str) -> Dict[str, str]:
-    out: Dict[str, str] = {}
+def load_dotenv_file(path: str) -> dict[str, str]:
+    out: dict[str, str] = {}
     try:
         with open(path) as fh:
             for raw in fh:
@@ -71,7 +69,7 @@ def load_dotenv_file(path: str) -> Dict[str, str]:
     return out
 
 
-def _persist_dotenv_values(path: str, values: Dict[str, str]) -> None:
+def _persist_dotenv_values(path: str, values: dict[str, str]) -> None:
     """Ensure ``values`` are present in ``path`` (.env style)."""
 
     try:
@@ -81,7 +79,7 @@ def _persist_dotenv_values(path: str, values: Dict[str, str]) -> None:
                 existing_lines = fh.read().splitlines()
         else:
             os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
-        mapping: Dict[str, str] = {}
+        mapping: dict[str, str] = {}
         order: list[str] = []
         for line in existing_lines:
             if not line or line.startswith("#") or "=" not in line:
@@ -109,7 +107,7 @@ def _persist_dotenv_values(path: str, values: Dict[str, str]) -> None:
         pass
 
 
-def persist_dotenv_values(values: Dict[str, str], *, cwd: str | None = None) -> str:
+def persist_dotenv_values(values: dict[str, str], *, cwd: str | None = None) -> str:
     path = os.path.join(cwd or os.getcwd(), ".env")
     _persist_dotenv_values(path, values)
     return path
@@ -121,14 +119,41 @@ def persist_env_api_key(key: str) -> None:
     _write_state(data)
 
 
-def modal_auth_status() -> Tuple[bool, str]:
+def persist_demo_dir(demo_dir: str) -> None:
+    """Store the demo directory path for subsequent commands."""
+    data = _read_state()
+    data["DEMO_DIR"] = demo_dir
+    _write_state(data)
+
+
+def load_demo_dir() -> str | None:
+    """Load the stored demo directory path, if any."""
+    data = _read_state()
+    return data.get("DEMO_DIR")
+
+
+def persist_env_file_path(env_path: str) -> None:
+    """Store the .env file path for subsequent commands."""
+    data = _read_state()
+    data["ENV_FILE_PATH"] = env_path
+    _write_state(data)
+
+
+def load_env_file_path() -> str | None:
+    """Load the stored .env file path, if any."""
+    data = _read_state()
+    return data.get("ENV_FILE_PATH")
+
+
+def modal_auth_status() -> tuple[bool, str]:
     """Return (ok, message) describing Modal CLI credential status."""
 
     env_token_id = (os.environ.get("MODAL_TOKEN_ID") or "").strip()
     env_token_secret = (os.environ.get("MODAL_TOKEN_SECRET") or "").strip()
 
     try:
-        from modal.config import config as modal_config, user_config_path
+        from modal.config import config as modal_config
+        from modal.config import user_config_path
     except Exception as exc:  # pragma: no cover - modal optional in some envs
         return False, f"Modal client unavailable ({exc})"
 
@@ -183,7 +208,7 @@ def load_env() -> DemoEnv:
     """
     env = DemoEnv()
 
-    os_env: Dict[str, str] = dict(os.environ)
+    os_env: dict[str, str] = dict(os.environ)
 
     # CWD .env
     cwd_env_path = os.path.join(os.getcwd(), ".env")
@@ -192,7 +217,9 @@ def load_env() -> DemoEnv:
     # Repo/package .envs (fallbacks)
     repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
     repo_env = load_dotenv_file(os.path.join(repo_root, ".env"))
-    pkg_env = load_dotenv_file(os.path.join(repo_root, "synth_ai", "demos", "demo_task_apps", "math", ".env"))
+    pkg_env = load_dotenv_file(
+        os.path.join(repo_root, "synth_ai", "demos", "demo_task_apps", "math", ".env")
+    )
     examples_env = load_dotenv_file(os.path.join(repo_root, "examples", "rl", ".env"))
 
     state = _read_state()
@@ -216,15 +243,12 @@ def load_env() -> DemoEnv:
         or pkg_env.get("DEV_BACKEND_URL")
         or ""
     ).strip()
-    use_dev = False
     if backend_override:
         dev_url = backend_override
-        use_dev = True
     elif dev_env:
         lower = dev_env.lower()
         if "localhost" in lower or "127.0.0.1" in lower or lower.endswith(":8000"):
             dev_url = dev_env
-            use_dev = True
         else:
             dev_url = prod_default
     else:
@@ -241,7 +265,11 @@ def load_env() -> DemoEnv:
         or str(state.get("SYNTH_API_KEY") or "")
     )
     if not synth_api_key:
-        mode = "prod" if default_root in dev_url else ("local" if ("localhost" in dev_url or "127.0.0.1" in dev_url) else "dev")
+        mode = (
+            "prod"
+            if default_root in dev_url
+            else ("local" if ("localhost" in dev_url or "127.0.0.1" in dev_url) else "dev")
+        )
         if mode == "prod":
             synth_api_key = (
                 os_env.get("PROD_SYNTH_API_KEY")
@@ -310,7 +338,9 @@ def load_env() -> DemoEnv:
     return env
 
 
-def assert_http_ok(url: str, method: str = "GET", allow_redirects: bool = True, timeout: float = 10.0) -> bool:
+def assert_http_ok(
+    url: str, method: str = "GET", allow_redirects: bool = True, timeout: float = 10.0
+) -> bool:
     try:
         import ssl
 
@@ -387,18 +417,24 @@ def persist_api_key(key: str) -> None:
     _write_state(data)
 
 
-def run_job(env: DemoEnv, config_toml_path: str, *, batch_size: Optional[int] = None, group_size: Optional[int] = None, model: Optional[str] = None) -> None:
+def run_job(
+    env: DemoEnv,
+    config_toml_path: str,
+    *,
+    batch_size: int | None = None,
+    group_size: int | None = None,
+    model: str | None = None,
+) -> None:
     """Create and stream a short RL job using the backend API (placeholder: prints cURL to execute)."""
     backend = env.dev_backend_url.rstrip("/")
-    if backend.endswith("/api"):
-        api_base = backend
-    else:
-        api_base = backend + "/api"
+    api_base = backend if backend.endswith("/api") else backend + "/api"
     print("\nTo create an RL job, run:")
     print(
-        "curl -s -X POST \"" + api_base + "/rl/jobs\" "
+        'curl -s -X POST "' + api_base + '/rl/jobs" '
         "-H 'Content-Type: application/json' "
         f"-H 'Authorization: Bearer {env.synth_api_key}' "
         "-d '{"  # intentionally not fully formed here for brevity in this scaffold
     )
-    print("  NOTE: CLI implementation will build the full JSON body with inline TOML config and stream events.")
+    print(
+        "  NOTE: CLI implementation will build the full JSON body with inline TOML config and stream events."
+    )

synth_ai/demos/demo_task_apps/crafter/configs/crafter_fft_4b.toml

@@ -8,8 +8,7 @@ variety = "fft"
 
 [job]
 model = "Qwen/Qwen3-4B"
-# Limit training to the first 100 conversations (export a 100-row JSONL and point to it here)
-# data = "../ft_data/qwen3_32b_ach_ge3_raw_filtered.head100.jsonl"
+data = "ft_data/crafter_traces.jsonl"
 
 [compute]
 # Adjust as needed for your quota
@@ -23,7 +22,7 @@ topology = {}
 
 # Optional local validation dataset path (JSONL). If set, the client will upload
 # this file and wire up validation so the frontend can display val.loss.
-validation_path = "../ft_data/qwen3_32b_ach_ge3_raw_filtered.tokens_1000000_seed_123.val_2000.jsonl"
+# validation_path = "../ft_data/crafter_validation.jsonl"
 
 [training]
 mode = "sft_offline"

synth_ai/demos/demo_task_apps/crafter/grpo_crafter_task_app.py

@@ -1,51 +1,57 @@
-
 """Compatibility wrapper for the GRPO Crafter task app.
 
-This module now delegates to the shared TaskAppConfig defined in
-`synth_ai.task.apps.grpo_crafter`. It is kept for legacy usage (running the
-file directly or targeting `fastapi_app` from external tooling). Prefer using
-`uvx synth-ai serve grpo-crafter` for local development and testing.
+This module now delegates to the TaskAppConfig defined in the local example at
+`examples/warming_up_to_rl/task_app/grpo_crafter.py`. It is kept for legacy usage
+(running the file directly or targeting `fastapi_app` from external tooling).
+Prefer using `uvx synth-ai serve grpo-crafter` for local development and testing.
 """
 
 from __future__ import annotations
 
 import argparse
+import importlib.util
 from pathlib import Path
 
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from starlette.requests import Request
-
 from synth_ai.task.apps import ModalDeploymentConfig, registry
-from synth_ai.task.apps.grpo_crafter import build_config
 from synth_ai.task.auth import is_api_key_header_authorized, normalize_environment_api_key
 from synth_ai.task.server import TaskAppConfig, create_task_app, run_task_app
 
 
+def _load_build_config():
+    # Find synth_ai package location to locate examples/
+    import synth_ai
+
+    synth_ai_path = Path(synth_ai.__file__).resolve().parent.parent
+    module_path = synth_ai_path / "examples" / "warming_up_to_rl" / "task_app" / "grpo_crafter.py"
+
+    if not module_path.exists():
+        raise ImportError(
+            f"Could not find task app module at {module_path}. Make sure you're running from the synth-ai repository."
+        )
+
+    spec = importlib.util.spec_from_file_location(
+        "warming_up_to_rl.task_app.grpo_crafter", module_path
+    )
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load task app module at {module_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.build_config
+
+
+build_config = _load_build_config()
+
+
 APP_ID = "grpo-crafter"
 
 
-_BASE_CONFIG = build_config()
-TASK_APP_CONFIG = TaskAppConfig(
-    app_id="grpo-crafter",
-    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,
-)
+def _build_base_config() -> TaskAppConfig:
+    # Lazily construct the base config to avoid heavy work at import time
+    return build_config()
+
 
 try:
     _REGISTERED_ENTRY = registry.get(APP_ID)
@@ -60,7 +66,8 @@ else:
 def build_task_app_config() -> TaskAppConfig:
     """Return a fresh TaskAppConfig for this wrapper."""
 
-    return TASK_APP_CONFIG.clone()
+    base = _build_base_config()
+    return base.clone()
 
 
 def fastapi_app():
@@ -122,7 +129,7 @@ def fastapi_app():
         try:
             hdr = request.headers
             snapshot = {
-                "path": str(getattr(request, "url").path),
+                "path": str(request.url.path),
                 "have_x_api_key": bool(hdr.get("x-api-key")),
                 "have_x_api_keys": bool(hdr.get("x-api-keys")),
                 "have_authorization": bool(hdr.get("authorization")),

synth_ai/demos/demo_task_apps/math/_common.py

@@ -6,6 +6,7 @@ This module provides a local fallback for install_problem_bank_into_shared so
 the modal task app can import it without requiring an external math_rl package.
 """
 
+
 def install_problem_bank_into_shared() -> None:
     """No-op placeholder for installing the Hendrycks MATH problem bank.
 
@@ -13,5 +14,3 @@ def install_problem_bank_into_shared() -> None:
     into a shared directory. For the demo scaffold, it is a no-op.
     """
     return None
-
-

synth_ai/demos/demo_task_apps/math/app.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+
 from fastapi import FastAPI
 from starlette.middleware.cors import CORSMiddleware
 
@@ -11,7 +12,7 @@ except Exception:  # fallback path when imported from repo root
     try:
         from examples.rl.task_app import make_app as make_rl_app  # type: ignore
     except Exception as e:  # pragma: no cover
-        raise ImportError(f"Unable to import RL task app: {e}")
+        raise ImportError(f"Unable to import RL task app: {e}") from e
 
 
 def create_app() -> FastAPI:

synth_ai/demos/demo_task_apps/math/deploy_modal.py

@@ -2,10 +2,9 @@ from __future__ import annotations
 
 import os
 import subprocess
-from typing import Optional
 
 
-def _parse_public_url_from_log(log_path: str) -> Optional[str]:
+def _parse_public_url_from_log(log_path: str) -> str | None:
     try:
         with open(log_path) as fh:
             for line in fh:
@@ -16,7 +15,7 @@ def _parse_public_url_from_log(log_path: str) -> Optional[str]:
     return None
 
 
-def deploy(script_path: Optional[str] = None, *, env_api_key: Optional[str] = None) -> str:
+def deploy(script_path: str | None = None, *, env_api_key: str | None = None) -> str:
     """
     Deploy the Math Task App to Modal and return the public URL.
 
@@ -55,6 +54,4 @@ def deploy(script_path: Optional[str] = None, *, env_api_key: Optional[str] = No
         raise RuntimeError(
             f"No deploy script provided and Python-based deploy failed: {e}. "
             "Pass --script /path/to/deploy_task_app.sh to demo.deploy."
-        )
-
-
+        ) from e