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

synth_ai/streaming/streamer.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+import contextlib
+import random
+from dataclasses import dataclass
+from typing import Any, Iterable, Sequence
+
+from synth_ai.http import AsyncHttpClient, sleep
+
+from .config import StreamConfig
+from .handlers import StreamHandler
+from .types import StreamMessage, StreamType
+
+TERMINAL_STATUSES = {"succeeded", "failed", "cancelled", "canceled", "completed"}
+TERMINAL_EVENT_SUCCESS = {
+    "sft.job.completed",
+    "rl.train.completed",
+    "rl.job.completed",
+    "workflow.completed",
+    "training.completed",
+}
+TERMINAL_EVENT_FAILURE = {
+    "sft.job.failed",
+    "rl.train.failed",
+    "rl.job.failed",
+    "workflow.failed",
+    "training.failed",
+}
+
+
+@dataclass(slots=True)
+class StreamEndpoints:
+    """Collection of endpoint paths (with optional fallbacks) to poll for a job."""
+
+    status: str | None
+    events: str | None = None
+    metrics: str | None = None
+    timeline: str | None = None
+    status_fallbacks: tuple[str, ...] = ()
+    event_fallbacks: tuple[str, ...] = ()
+    metric_fallbacks: tuple[str, ...] = ()
+    timeline_fallbacks: tuple[str, ...] = ()
+
+    @classmethod
+    def learning(cls, job_id: str) -> StreamEndpoints:
+        base = f"/learning/jobs/{job_id}"
+        return cls(
+            status=base,
+            events=f"{base}/events",
+            metrics=f"{base}/metrics",
+            timeline=f"{base}/timeline",
+        )
+
+    @classmethod
+    def rl(cls, job_id: str) -> StreamEndpoints:
+        base = f"/rl/jobs/{job_id}"
+        return cls(
+            status=base,
+            events=f"{base}/events",
+            metrics=f"{base}/metrics",
+            timeline=f"{base}/timeline",
+            status_fallbacks=(
+                f"/learning/jobs/{job_id}",
+                f"/orchestration/jobs/{job_id}",
+            ),
+            event_fallbacks=(
+                f"/learning/jobs/{job_id}/events",
+                f"/orchestration/jobs/{job_id}/events",
+            ),
+            metric_fallbacks=(
+                f"/learning/jobs/{job_id}/metrics",
+            ),
+            timeline_fallbacks=(
+                f"/learning/jobs/{job_id}/timeline",
+            ),
+        )
+
+
+class JobStreamer:
+    """Poll job endpoints and dispatch messages to configured handlers."""
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str,
+        job_id: str,
+        endpoints: StreamEndpoints | None = None,
+        config: StreamConfig | None = None,
+        handlers: Sequence[StreamHandler] | None = None,
+        interval_seconds: float = 2.0,
+        timeout_seconds: float | None = None,
+        http_timeout: float = 60.0,
+        http_client: AsyncHttpClient | None = None,
+        sleep_fn= sleep,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.job_id = job_id
+        self.endpoints = endpoints or StreamEndpoints.learning(job_id)
+        self.config = config or StreamConfig.default()
+        self.handlers: list[StreamHandler] = list(handlers or [])
+        self.interval_seconds = interval_seconds
+        self.timeout_seconds = timeout_seconds
+        self.http_timeout = http_timeout
+        self._http = http_client
+        self._sleep = sleep_fn
+
+        status_sources: list[str | None] = [self.endpoints.status]
+        status_sources.extend(self.endpoints.status_fallbacks)
+        self._status_paths = [p for p in status_sources if p]
+
+        event_sources: list[str | None] = [self.endpoints.events]
+        event_sources.extend(self.endpoints.event_fallbacks)
+        self._event_paths = [p for p in event_sources if p]
+
+        metric_sources: list[str | None] = [self.endpoints.metrics]
+        metric_sources.extend(self.endpoints.metric_fallbacks)
+        self._metric_paths = [p for p in metric_sources if p]
+
+        timeline_sources: list[str | None] = [self.endpoints.timeline]
+        timeline_sources.extend(self.endpoints.timeline_fallbacks)
+        self._timeline_paths = [p for p in timeline_sources if p]
+
+        self._last_seq_by_stream: dict[str, int] = {}
+        self._last_step_by_metric: dict[str, int] = {}
+        self._seen_messages: set[str] = set()
+        self._last_status_payload: dict[str, Any] | None = None
+        self._last_status_value: str | None = None
+        self._terminal_seen = False
+        self._terminal_event_status: str | None = None
+
+        if not self.handlers:
+            from .handlers import CLIHandler
+
+            self.handlers = [CLIHandler()]
+
+    async def stream_until_terminal(self) -> dict[str, Any]:
+        """Stream configured endpoints until the job reaches a terminal state."""
+        http_cm = self._http or AsyncHttpClient(self.base_url, self.api_key, timeout=self.http_timeout)
+        async with http_cm as http:
+            while True:
+                status = await self._refresh_status(http)
+
+                event_messages = await self._poll_events(http)
+                metric_messages = await self._poll_metrics(http)
+                timeline_messages = await self._poll_timeline(http)
+
+                self._dispatch(event_messages + metric_messages + timeline_messages)
+
+                if self._terminal_seen or (status and status in TERMINAL_STATUSES):
+                    break
+
+                await self._sleep(self.interval_seconds)
+
+        for handler in self.handlers:
+            with contextlib.suppress(Exception):
+                handler.flush()
+
+        final_status = self._terminal_event_status or self._last_status_value or "unknown"
+        if self._last_status_payload:
+            self._last_status_payload["status"] = final_status
+            return self._last_status_payload
+        return {"job_id": self.job_id, "status": final_status}
+
+    async def _refresh_status(self, http: AsyncHttpClient) -> str:
+        status_payload = await self._poll_status(http)
+        if status_payload:
+            self._last_status_payload = status_payload
+            status = str(status_payload.get("status") or status_payload.get("state") or "").lower()
+            if status:
+                self._last_status_value = status
+                if status in TERMINAL_STATUSES:
+                    self._terminal_seen = True
+            return status
+        return self._last_status_value or ""
+
+    async def _poll_status(self, http: AsyncHttpClient) -> dict[str, Any] | None:
+        if StreamType.STATUS not in self.config.enabled_streams or not self._status_paths:
+            return None
+
+        for path in self._status_paths:
+            try:
+                data = await http.get(path)
+            except Exception:
+                continue
+            if isinstance(data, dict):
+                message = StreamMessage.from_status(self.job_id, data)
+                self._dispatch([message])
+                return data
+        return None
+
+    async def _poll_events(self, http: AsyncHttpClient) -> list[StreamMessage]:
+        if StreamType.EVENTS not in self.config.enabled_streams or not self._event_paths:
+            return []
+        messages: list[StreamMessage] = []
+        total = 0
+        for path in self._event_paths:
+            since = self._last_seq_by_stream.get(path, 0)
+            params = {"since_seq": since, "limit": 200}
+            try:
+                data = await http.get(path, params=params)
+            except Exception:
+                continue
+            raw_events = _extract_list(data, "events")
+            for event in raw_events:
+                seq = int(event.get("seq") or 0)
+                if seq <= self._last_seq_by_stream.get(path, 0):
+                    continue
+                if not self.config.should_include_event(event):
+                    continue
+                self._last_seq_by_stream[path] = seq
+                event_job_id = event.get("job_id") or self.job_id
+                event_message = StreamMessage.from_event(event_job_id, event)
+                event_type = str(event.get("type") or "").lower()
+                if event_type in TERMINAL_EVENT_SUCCESS:
+                    self._terminal_seen = True
+                    self._terminal_event_status = "succeeded"
+                elif event_type in TERMINAL_EVENT_FAILURE:
+                    self._terminal_seen = True
+                    self._terminal_event_status = "failed"
+                messages.append(event_message)
+                total += 1
+                if self.config.max_events_per_poll and total >= self.config.max_events_per_poll:
+                    return messages
+        return messages
+
+    async def _poll_metrics(self, http: AsyncHttpClient) -> list[StreamMessage]:
+        if StreamType.METRICS not in self.config.enabled_streams or not self._metric_paths:
+            return []
+        messages: list[StreamMessage] = []
+        for path in self._metric_paths:
+            after = max(self._last_step_by_metric.values()) if self._last_step_by_metric else -1
+            params = {"after_step": after, "limit": 200}
+            try:
+                data = await http.get(path, params=params)
+            except Exception:
+                continue
+            points = _extract_list(data, "points")
+            for point in points:
+                name = point.get("name", "")
+                step = int(point.get("step") or -1)
+                if step <= self._last_step_by_metric.get(name, -1):
+                    continue
+                if not self.config.should_include_metric(point):
+                    continue
+                self._last_step_by_metric[name] = step
+                metric_job_id = point.get("job_id") or self.job_id
+                messages.append(StreamMessage.from_metric(metric_job_id, point))
+        return messages
+
+    async def _poll_timeline(self, http: AsyncHttpClient) -> list[StreamMessage]:
+        if StreamType.TIMELINE not in self.config.enabled_streams or not self._timeline_paths:
+            return []
+        messages: list[StreamMessage] = []
+        for path in self._timeline_paths:
+            try:
+                data = await http.get(path)
+            except Exception:
+                continue
+
+            timeline_entries = _extract_list(data, "events")
+            for entry in timeline_entries:
+                if not self.config.should_include_timeline(entry):
+                    continue
+                timeline_job_id = entry.get("job_id") or self.job_id
+                phase = str(entry.get("phase") or "").lower()
+                if phase in TERMINAL_STATUSES:
+                    self._terminal_seen = True
+                    if phase in {"failed", "cancelled", "canceled"}:
+                        self._terminal_event_status = "failed"
+                    elif phase:
+                        self._terminal_event_status = "succeeded"
+                messages.append(StreamMessage.from_timeline(timeline_job_id, entry))
+        return messages
+
+    def _dispatch(self, messages: Iterable[StreamMessage]) -> None:
+        for message in messages:
+            if self.config.deduplicate and message.key in self._seen_messages:
+                continue
+            if self.config.sample_rate < 1.0 and random.random() > self.config.sample_rate:
+                continue
+            if self.config.deduplicate:
+                self._seen_messages.add(message.key)
+
+            for handler in self.handlers:
+                try:
+                    if handler.should_handle(message):
+                        handler.handle(message)
+                except Exception:
+                    pass
+
+
+def _extract_list(data: Any, field: str) -> list[dict[str, Any]]:
+    raw = (data or {}).get(field) if isinstance(data, dict) else None
+    if isinstance(raw, list):
+        return [item for item in raw if isinstance(item, dict)]
+    return []
+
+
+__all__ = ["JobStreamer", "StreamEndpoints"]

synth_ai/streaming/types.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Any
+
+
+class StreamType(Enum):
+    """Categories of streaming payloads emitted by training jobs."""
+
+    STATUS = auto()
+    EVENTS = auto()
+    METRICS = auto()
+    TIMELINE = auto()
+
+    @property
+    def endpoint_path(self) -> str:
+        """Return the endpoint suffix used when polling this stream."""
+        return {
+            StreamType.STATUS: "",
+            StreamType.EVENTS: "/events",
+            StreamType.METRICS: "/metrics",
+            StreamType.TIMELINE: "/timeline",
+        }[self]
+
+
+@dataclass(slots=True)
+class StreamMessage:
+    """Unified representation of a streaming payload."""
+
+    stream_type: StreamType
+    timestamp: str
+    job_id: str
+    data: dict[str, Any]
+    seq: int | None = None
+    step: int | None = None
+    phase: str | None = None
+
+    @property
+    def key(self) -> str:
+        """Return a unique identifier used for deduplication."""
+        if self.stream_type is StreamType.EVENTS:
+            return f"event:{self.seq}"
+        if self.stream_type is StreamType.METRICS:
+            name = self.data.get("name", "")
+            return f"metric:{name}:{self.step}"
+        if self.stream_type is StreamType.TIMELINE:
+            return f"timeline:{self.phase}:{self.timestamp}"
+        return f"status:{self.timestamp}"
+
+    @classmethod
+    def from_status(cls, job_id: str, status_data: dict[str, Any]) -> StreamMessage:
+        """Create a message representing a job status payload."""
+        return cls(
+            stream_type=StreamType.STATUS,
+            timestamp=status_data.get("updated_at", "") or status_data.get("created_at", ""),
+            job_id=job_id,
+            data=status_data,
+        )
+
+    @classmethod
+    def from_event(cls, job_id: str, event_data: dict[str, Any]) -> StreamMessage:
+        """Create a message describing a job event."""
+        return cls(
+            stream_type=StreamType.EVENTS,
+            timestamp=event_data.get("created_at", ""),
+            job_id=job_id,
+            data=event_data,
+            seq=event_data.get("seq"),
+        )
+
+    @classmethod
+    def from_metric(cls, job_id: str, metric_data: dict[str, Any]) -> StreamMessage:
+        """Create a message describing a metric point."""
+        return cls(
+            stream_type=StreamType.METRICS,
+            timestamp=metric_data.get("created_at", ""),
+            job_id=job_id,
+            data=metric_data,
+            step=metric_data.get("step"),
+        )
+
+    @classmethod
+    def from_timeline(cls, job_id: str, timeline_data: dict[str, Any]) -> StreamMessage:
+        """Create a message describing a status timeline entry."""
+        return cls(
+            stream_type=StreamType.TIMELINE,
+            timestamp=timeline_data.get("created_at", ""),
+            job_id=job_id,
+            data=timeline_data,
+            phase=timeline_data.get("phase"),
+        )
+
+
+__all__ = ["StreamMessage", "StreamType"]

synth_ai/task/validators.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, cast
+from typing import Any
 from urllib.parse import urlparse, urlunparse
 
 import click
@@ -151,7 +151,7 @@ def normalize_inference_url(url: str | None, *, default: str = "https://api.open
         new_path = f"{path}/v1/chat/completions" if path else "/v1/chat/completions"
     
     # Reconstruct URL with new path and original query/fragment
-    return cast(str, urlunparse(parsed._replace(path=new_path)))
+    return urlunparse(parsed._replace(path=new_path))
 
 
 def validate_task_app_url(url: str | None) -> str:

synth_ai/tracing_v3/migration_helper.py

@@ -68,7 +68,7 @@ def categorize_files(v2_files: list[tuple[str, list[str]]]) -> dict:
             categories["examples"].append((file_path, imports))
         elif any(
             core in file_path
-            for core in ["synth_ai/lm/", "synth_ai/tui/", "synth_ai/environments/"]
+            for core in ["synth_ai/lm/", "synth_ai/environments/"]
         ):
             categories["core_library"].append((file_path, imports))
         else:
@@ -104,7 +104,6 @@ def print_migration_report():
     print("2. Debug scripts: Can be deleted or archived")
     print("3. Core library files: Need careful migration to v3")
     print("   - synth_ai/lm/core/main_v2.py")
-    print("   - synth_ai/tui/cli/query_experiments.py")
     print("   - synth_ai/environments/service/core_routes.py")
     print("4. Examples: Should be updated to demonstrate v3 usage")
 

synth_ai/utils/env.py

@@ -127,11 +127,17 @@ def filter_json_files_by_key(key: str, paths: list[Path]) -> list[tuple[Path, st
     return matches
 
 
-def resolve_env_var(key: str) -> None:
+def ensure_env_var(key: str, expected_value: str) -> None:
+    actual_value = os.getenv(key)
+    if expected_value != actual_value:
+        raise ValueError(f"Expected: {key}={expected_value}\nActual: {key}={actual_value}")
+
+
+def resolve_env_var(key: str) -> str:
     env_value = os.getenv(key)
     if env_value is not None:
         click.echo(f"Using {key}={mask_str(env_value)} from process environment")
-        return
+        return env_value
 
     value: str = ""
 
@@ -167,8 +173,7 @@ def resolve_env_var(key: str) -> None:
                     show_choices=False,
                 ).strip()
             except click.Abort:
-                return
-
+                raise
             if choice.lower() == 'm':
                 value = _prompt_manual_env_value(key)
                 break
@@ -186,20 +191,22 @@ def resolve_env_var(key: str) -> None:
             click.echo(f"Invalid selection. Enter a number between 1 and {len(options)} or 'm'.")
 
     else:
-        click.echo(f"No value found for {key}")
+        print(f"No value found for {key}")
         value = _prompt_manual_env_value(key)
     
     os.environ[key] = value
-    click.echo(f"Loaded {key}={mask_str(value)} into process environment")
-    return
+    ensure_env_var(key, value)
+    print(f"Loaded {key}={mask_str(value)} into process environment")
+    return value
 
 
 def write_env_var_to_dotenv(
     key: str,
     value: str,
-    output_file_path: str | Path,
+    output_file_path: str | Path | None = None,
 ) -> None:
-    path = Path(output_file_path).expanduser()
+    path = Path(".env") if output_file_path is None else Path(output_file_path)
+    path = path.expanduser()
     path.parent.mkdir(parents=True, exist_ok=True)
 
     encoded_value = _format_env_value(value)
@@ -212,7 +219,7 @@ def write_env_var_to_dotenv(
             with path.open('r', encoding="utf-8") as handle:
                 lines = handle.readlines()
         except OSError as exc:
-            raise click.ClickException(f"Failed to read {path}: {exc}") from exc
+            raise RuntimeError(f"Failed to read {path}: {exc}") from exc
 
         for index, line in enumerate(lines):
             parsed = _parse_env_assignment(line)
@@ -238,9 +245,9 @@ def write_env_var_to_dotenv(
         with path.open('w', encoding="utf-8") as handle:
             handle.writelines(lines)
     except OSError as exc:
-        raise click.ClickException(f"Failed to write {path}: {exc}") from exc
+        raise RuntimeError(f"Failed to write {path}: {exc}") from exc
 
-    click.echo(f"Wrote {key}={mask_str(value)} to {path}")
+    print(f"Wrote {key}={mask_str(value)} to {path.resolve()}")
 
 
 def write_env_var_to_json(
@@ -250,7 +257,7 @@ def write_env_var_to_json(
 ) -> None:
     path = Path(output_file_path).expanduser()
     if path.exists() and not path.is_file():
-        raise click.ClickException(f"{path} exists and is not a file")
+        raise RuntimeError(f"{path} exists and is not a file")
 
     data: dict[str, str] = {}
 
@@ -259,12 +266,12 @@ def write_env_var_to_json(
             with path.open('r', encoding="utf-8") as handle:
                 existing = json.load(handle)
         except json.JSONDecodeError as exc:
-            raise click.ClickException(f"Invalid JSON in {path}: {exc}") from exc
+            raise RuntimeError(f"Invalid JSON in {path}: {exc}") from exc
         except OSError as exc:
-            raise click.ClickException(f"Failed to read {path}: {exc}") from exc
+            raise RuntimeError(f"Failed to read {path}: {exc}") from exc
 
         if not isinstance(existing, dict):
-            raise click.ClickException(f"Expected JSON object in {path}")
+            raise RuntimeError(f"Expected JSON object in {path}")
 
         for existing_key, existing_value in existing.items():
             if existing_key == key:
@@ -282,6 +289,6 @@ def write_env_var_to_json(
             json.dump(data, handle, indent=2, sort_keys=True)
             handle.write('\n')
     except OSError as exc:
-        raise click.ClickException(f"Failed to write {path}: {exc}") from exc
+        raise RuntimeError(f"Failed to write {path}: {exc}") from exc
 
-    click.echo(f"Wrote {key}={mask_str(value)} to {path}")
+    print(f"Wrote {key}={mask_str(value)} to {path}")

synth_ai/utils/http.py

@@ -34,7 +34,10 @@ class AsyncHttpClient:
 
     async def __aenter__(self) -> AsyncHttpClient:
         if self._session is None:
-            headers = {"authorization": f"Bearer {self._api_key}"}
+            headers = {
+                "authorization": f"Bearer {self._api_key}",
+                "accept": "application/json",
+            }
             user_id = os.getenv("SYNTH_USER_ID") or os.getenv("X_USER_ID") or os.getenv("USER_ID")
             if user_id:
                 headers["X-User-ID"] = user_id

synth_ai/utils/modal.py

@@ -4,7 +4,7 @@ import os
 import shutil
 import sys
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 from urllib.parse import urlparse, urlunparse
 
 from synth_ai.demos import core as demo_core
@@ -63,7 +63,7 @@ def normalize_endpoint_url(url: str) -> str:
                     creds += f":{parsed.password}"
                 netloc = f"{creds}@{netloc}"
             parsed = parsed._replace(netloc=netloc)
-            return cast(str, urlunparse(parsed))
+            return urlunparse(parsed)
     except Exception:
         pass
     return url

{synth_ai-0.2.16.dist-info → synth_ai-0.2.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.2.16
+Version: 0.2.17
 Summary: RL as a service SDK - Core AI functionality and tracing
 Author-email: Synth AI <josh@usesynth.ai>
 License-Expression: MIT
@@ -19,6 +19,7 @@ Requires-Dist: tqdm>=4.66.4
 Requires-Dist: jsonschema>=4.23.0
 Requires-Dist: backoff>=2.0.0
 Requires-Dist: typing_extensions>=4.0.0
+Requires-Dist: rich>=13.9.0
 Requires-Dist: openai>=1.99.0
 Requires-Dist: anthropic>=0.42.0
 Requires-Dist: langfuse<3.0.0,>=2.53.9
@@ -46,7 +47,6 @@ Requires-Dist: google-api-core>=2.25.1
 Requires-Dist: google-generativeai>=0.8.5
 Requires-Dist: crafter>=1.8.3
 Requires-Dist: click<8.2,>=8.1.7
-Requires-Dist: textual>=1.1.0
 Requires-Dist: openai-harmony>=0.0.1
 Requires-Dist: asyncpg>=0.30.0
 Requires-Dist: aiohttp>=3.8.0
@@ -71,9 +71,14 @@ Requires-Dist: ruff>=0.1.0; extra == "dev"
 Provides-Extra: research
 Requires-Dist: crafter>=1.8.3; extra == "research"
 Requires-Dist: datasets>=4.0.0; extra == "research"
+Provides-Extra: swe
+Requires-Dist: morphcloud>=0.1.3; extra == "swe"
+Requires-Dist: swebench>=2.3.0; extra == "swe"
 Provides-Extra: all
 Requires-Dist: crafter>=1.8.3; extra == "all"
 Requires-Dist: datasets>=4.0.0; extra == "all"
+Requires-Dist: morphcloud>=0.1.3; extra == "all"
+Requires-Dist: swebench>=2.3.0; extra == "all"
 Provides-Extra: analytics
 Requires-Dist: pandas>=2.2.3; extra == "analytics"
 Dynamic: license-file
@@ -92,7 +97,7 @@ Dynamic: license-file
 
 ---
 
-## 🚀 Install
+## 🚀 Install version 0.2.16
 
 ```bash
 pip install synth-ai