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

examples/workflows/math_rl/run_rl_and_save.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""Submit math RL training jobs via Synth backend."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import requests
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        print(f"config not found: {path}", file=sys.stderr)
+        sys.exit(2)
+    with path.open("rb") as fh:
+        return tomllib.load(fh)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Create math RL job via backend RL endpoint")
+    parser.add_argument(
+        "--backend", default=os.getenv("BACKEND_BASE_URL", "http://localhost:8000/api")
+    )
+    parser.add_argument("--config", required=True, help="Path to RL TOML config")
+    parser.add_argument(
+        "--task-url", default=os.getenv("TASK_APP_URL", ""), help="Override task service URL"
+    )
+    parser.add_argument(
+        "--idempotency",
+        default=os.getenv("RL_IDEMPOTENCY_KEY", ""),
+        help="Optional Idempotency-Key header",
+    )
+    args = parser.parse_args()
+
+    cfg_path = Path(args.config).expanduser()
+    cfg = _load_toml(cfg_path)
+
+    services = cfg.get("services") if isinstance(cfg.get("services"), dict) else {}
+
+    task_url = (
+        (args.task_url or "").strip()
+        or (os.getenv("TASK_APP_URL") or "").strip()
+        or (services.get("task_url") or "").strip()
+    )
+    if not task_url:
+        print(
+            "Missing task service URL. Provide --task-url or set TASK_APP_URL or services.task_url in TOML",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+
+    model_cfg = cfg.get("model") if isinstance(cfg.get("model"), dict) else {}
+    has_source = bool((model_cfg.get("source") or "").strip())
+    has_base = bool((model_cfg.get("base") or "").strip())
+    if has_source == has_base:
+        print(
+            "Model section must specify exactly one of [model].source or [model].base",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+
+    payload: dict[str, Any] = {
+        "job_type": "rl",
+        "compute": cfg.get("compute", {}),
+        "data": {
+            "endpoint_base_url": task_url,
+            "config": cfg,
+        },
+        "tags": cfg.get("tags", {}),
+    }
+
+    backend = str(args.backend).rstrip("/")
+    url = f"{backend}/rl/jobs"
+    api_key = (os.getenv("SYNTH_API_KEY") or os.getenv("SYNTH_KEY") or "").strip()
+    if not api_key:
+        print("Missing SYNTH_API_KEY in env", file=sys.stderr)
+        sys.exit(2)
+
+    headers = {
+        "content-type": "application/json",
+        "authorization": f"Bearer {api_key}",
+    }
+    idem = (args.idempotency or "").strip()
+    if idem:
+        headers["Idempotency-Key"] = idem
+
+    print(f"[INFO] POST {url}")
+    try:
+        preview = {"job_type": payload["job_type"], "data": {"config_keys": list(cfg.keys())}}
+        print(f"[INFO] Payload preview: {json.dumps(preview)}")
+    except Exception:
+        pass
+
+    resp = requests.post(url, headers=headers, json=payload, timeout=120)
+    ok = resp.status_code in (200, 201)
+    try:
+        snippet = resp.json()
+    except Exception:
+        snippet = resp.text[:300]
+    print(f"[INFO] Response: {resp.status_code} {snippet}")
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()

synth_ai/__init__.py

@@ -1,36 +1,60 @@
-"""
-Synth AI - Software for aiding the best and multiplying the will.
-"""
+from __future__ import annotations
 
-# Environment exports - moved from synth-env
-from synth_ai.environments import *  # noqa
-import synth_ai.environments as environments  # expose module name for __all__
-try:
-    from synth_ai.lm.core.main import LM  # Moved from zyk to lm for better organization
-except Exception:  # allow minimal imports (e.g., tracing) without LM stack
-    LM = None  # type: ignore
-try:
-    from synth_ai.lm.provider_support.anthropic import Anthropic, AsyncAnthropic
-except Exception:  # optional in minimal environments
-    Anthropic = AsyncAnthropic = None  # type: ignore
+import importlib
+from importlib import metadata as _metadata
+from importlib.metadata import PackageNotFoundError
+from pathlib import Path
+from typing import Any, cast
 
-# Provider support exports - moved from synth-sdk to synth_ai/lm
+# Install log filter as early as possible to suppress noisy codex_otel logs
 try:
-    from synth_ai.lm.provider_support.openai import AsyncOpenAI, OpenAI
+    from synth_ai.utils.log_filter import install_log_filter
+    install_log_filter()
 except Exception:
-    AsyncOpenAI = OpenAI = None  # type: ignore
+    # Silently fail if log filter can't be installed
+    pass
+
+import synth_ai.environments as environments  # expose module name for __all__
+from synth_ai.environments import *  # noqa
+from synth_ai.judge_schemas import (
+    CriterionScorePayload,
+    JudgeOptions,
+    JudgeScoreRequest,
+    JudgeScoreResponse,
+    JudgeTaskApp,
+    JudgeTracePayload,
+    ReviewPayload,
+)
+
+try:  # Prefer the installed package metadata when available
+    __version__ = _metadata.version("synth-ai")
+except PackageNotFoundError:  # Fallback to pyproject version for editable installs
+    try:
+        import tomllib as _toml  # Python 3.11+
+    except ModuleNotFoundError:  # pragma: no cover - legacy interpreter guard
+        import tomli as _toml  # type: ignore[no-redef]
+
+    try:
+        pyproject_path = Path(__file__).resolve().parents[1] / "pyproject.toml"
+        with pyproject_path.open("rb") as fh:
+            _pyproject = _toml.load(fh)
+        __version__ = str(_pyproject["project"]["version"])
+    except Exception:
+        __version__ = "0.0.0.dev0"
 
 # Legacy tracing v1 is not required for v3 usage and can be unavailable in minimal envs.
 tracing = None  # type: ignore
 EventPartitionElement = RewardSignal = SystemTrace = TrainingQuestion = None  # type: ignore
 trace_event_async = trace_event_sync = upload = None  # type: ignore
 
-__version__ = "0.2.6.dev4"
 __all__ = [
-    "LM",
-    "OpenAI",
-    "AsyncOpenAI",
-    "Anthropic",
-    "AsyncAnthropic",
     "environments",
+    # Judge API contracts
+    "JudgeScoreRequest",
+    "JudgeScoreResponse",
+    "JudgeOptions",
+    "JudgeTaskApp",
+    "JudgeTracePayload",
+    "ReviewPayload",
+    "CriterionScorePayload",
 ]  # Explicitly define public API (v1 tracing omitted in minimal env)

synth_ai/_utils/__init__.py

@@ -0,0 +1,47 @@
+"""
+Compatibility shims for legacy `synth_ai._utils.*` imports.
+
+The modern codebase exposes these helpers under ``synth_ai.utils``.  These
+modules re-export the public symbols so existing downstream code (and our own
+older examples/tests) continue to work without modification.
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+from types import ModuleType
+
+_MAPPING = {
+    "base_url": "synth_ai.utils.base_url",
+    "http": "synth_ai.utils.http",
+    "prompts": "synth_ai.utils.prompts",
+    "task_app_state": "synth_ai.utils.task_app_state",
+    "user_config": "synth_ai.utils.user_config",
+}
+
+__all__ = sorted(_MAPPING.keys())
+
+
+def __getattr__(name: str) -> ModuleType:
+    target = _MAPPING.get(name)
+    if not target:
+        raise AttributeError(f"module 'synth_ai._utils' has no attribute '{name}'")
+    module = import_module(target)
+    globals()[name] = module
+    return module
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))
+
+
+def _export(module_name: str) -> None:
+    module = import_module(_MAPPING[module_name])
+    globals().setdefault(module_name, module)
+    if hasattr(module, "__all__"):
+        for attr in module.__all__:  # type: ignore[attr-defined]
+            globals().setdefault(attr, getattr(module, attr))
+
+
+for _name in __all__:
+    _export(_name)

synth_ai/_utils/base_url.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from synth_ai.utils.base_url import *  # noqa: F401,F403
+
+try:
+    from synth_ai.utils.base_url import __all__ as __wrapped_all__  # type: ignore[attr-defined]
+except ImportError:  # pragma: no cover - defensive
+    __wrapped_all__ = []
+
+__all__ = list(__wrapped_all__)

synth_ai/_utils/http.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from synth_ai.utils.http import *  # noqa: F401,F403
+
+try:
+    from synth_ai.utils.http import __all__ as __wrapped_all__  # type: ignore[attr-defined]
+except ImportError:  # pragma: no cover - defensive
+    __wrapped_all__ = []
+
+__all__ = list(__wrapped_all__)

synth_ai/_utils/prompts.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from synth_ai.utils.prompts import *  # noqa: F401,F403
+
+try:
+    from synth_ai.utils.prompts import __all__ as __wrapped_all__  # type: ignore[attr-defined]
+except ImportError:  # pragma: no cover - defensive
+    __wrapped_all__ = []
+
+__all__ = list(__wrapped_all__)

synth_ai/_utils/task_app_state.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from synth_ai.utils.task_app_state import *  # noqa: F401,F403
+
+try:
+    from synth_ai.utils.task_app_state import (
+        __all__ as __wrapped_all__,  # type: ignore[attr-defined]
+    )
+except ImportError:  # pragma: no cover - defensive
+    __wrapped_all__ = []
+
+__all__ = list(__wrapped_all__)

synth_ai/_utils/user_config.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from synth_ai.utils.user_config import *  # noqa: F401,F403
+
+try:
+    from synth_ai.utils.user_config import __all__ as __wrapped_all__  # type: ignore[attr-defined]
+except ImportError:  # pragma: no cover - defensive
+    __wrapped_all__ = []
+
+__all__ = list(__wrapped_all__)