synth-ai 0.2.8.dev4__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

synth_ai/learning/client.py

@@ -1,9 +1,17 @@
 from __future__ import annotations
 
+from collections.abc import Callable
+from contextlib import suppress
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, TypedDict
 
-from ..http import AsyncHttpClient, HTTPError, sleep
+from synth_ai.api.models.supported import (
+    UnsupportedModelError,
+    normalize_model_identifier,
+)
+from synth_ai.learning.sft.config import prepare_sft_job_payload
+
+from .._utils.http import AsyncHttpClient, HTTPError, sleep
 
 
 class LearningClient:
@@ -20,7 +28,12 @@ class LearningClient:
             files = {"file": (p.name, content, _infer_content_type(p.name))}
             js = await http.post_multipart("/api/learning/files", data=data, files=files)
         if not isinstance(js, dict) or "id" not in js:
-            raise HTTPError(status=500, url="/api/learning/files", message="invalid_upload_response", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500,
+                url="/api/learning/files",
+                message="invalid_upload_response",
+                body_snippet=str(js)[:200],
+            )
         return str(js["id"])
 
     async def create_job(
@@ -29,28 +42,56 @@ class LearningClient:
         training_type: str,
         model: str,
         training_file_id: str,
-        hyperparameters: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        body = {
-            "training_type": training_type,
-            "model": model,
-            "training_file_id": training_file_id,
-            "hyperparameters": hyperparameters or {},
-            "metadata": metadata or {},
-        }
+        hyperparameters: dict[str, Any] | None = None,
+        metadata: dict[str, Any] | None = None,
+        validation_file: str | None = None,
+    ) -> dict[str, Any]:
+        lower_type = (training_type or "").strip().lower()
+        require_base = (
+            lower_type.startswith("sft")
+            or lower_type.startswith("fft")
+            or lower_type.startswith("qft")
+        )
+        try:
+            normalized_model = normalize_model_identifier(
+                model, allow_finetuned_prefixes=not require_base
+            )
+        except UnsupportedModelError as exc:
+            raise ValueError(str(exc)) from exc
+
+        if lower_type.startswith("sft") or lower_type in {"fft", "qft"}:
+            body = prepare_sft_job_payload(
+                model=model,
+                training_file=training_file_id,
+                hyperparameters=hyperparameters,
+                metadata=metadata,
+                training_type=training_type or "sft_offline",
+                validation_file=validation_file,
+                training_file_field="training_file_id",
+                require_training_file=True,
+            )
+        else:
+            body = {
+                "training_type": training_type,
+                "model": normalized_model,
+                "training_file_id": training_file_id,
+                "hyperparameters": hyperparameters or {},
+                "metadata": metadata or {},
+            }
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             return await http.post_json("/api/learning/jobs", json=body)
 
-    async def start_job(self, job_id: str) -> Dict[str, Any]:
+    async def start_job(self, job_id: str) -> dict[str, Any]:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             return await http.post_json(f"/api/learning/jobs/{job_id}/start", json={})
 
-    async def get_job(self, job_id: str) -> Dict[str, Any]:
+    async def get_job(self, job_id: str) -> dict[str, Any]:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             return await http.get(f"/api/learning/jobs/{job_id}")
 
-    async def get_events(self, job_id: str, *, since_seq: int = 0, limit: int = 200) -> List[Dict[str, Any]]:
+    async def get_events(
+        self, job_id: str, *, since_seq: int = 0, limit: int = 200
+    ) -> list[dict[str, Any]]:
         params = {"since_seq": since_seq, "limit": limit}
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             js = await http.get(f"/api/learning/jobs/{job_id}/events", params=params)
@@ -58,8 +99,16 @@ class LearningClient:
             return js["events"]
         return []
 
-    async def get_metrics(self, job_id: str, *, name: str | None = None, after_step: int | None = None, limit: int = 500, run_id: str | None = None) -> List[Dict[str, Any]]:
-        params: Dict[str, Any] = {"limit": limit}
+    async def get_metrics(
+        self,
+        job_id: str,
+        *,
+        name: str | None = None,
+        after_step: int | None = None,
+        limit: int = 500,
+        run_id: str | None = None,
+    ) -> list[dict[str, Any]]:
+        params: dict[str, Any] = {"limit": limit}
         if name is not None:
             params["name"] = name
         if after_step is not None:
@@ -72,7 +121,7 @@ class LearningClient:
             return js["points"]
         return []
 
-    async def get_timeline(self, job_id: str, *, limit: int = 200) -> List[Dict[str, Any]]:
+    async def get_timeline(self, job_id: str, *, limit: int = 200) -> list[dict[str, Any]]:
         params = {"limit": limit}
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             js = await http.get(f"/api/learning/jobs/{job_id}/timeline", params=params)
@@ -86,8 +135,8 @@ class LearningClient:
         *,
         interval_seconds: float = 2.0,
         max_seconds: float | None = 3600,
-        on_event: Callable[[Dict[str, Any]], None] | None = None,
-    ) -> Dict[str, Any]:
+        on_event: Callable[[dict[str, Any]], None] | None = None,
+    ) -> dict[str, Any]:
         last_seq = 0
         elapsed = 0.0
         while True:
@@ -97,10 +146,8 @@ class LearningClient:
                 if isinstance(e, dict) and isinstance(e.get("seq"), int):
                     last_seq = max(last_seq, int(e["seq"]))
                 if on_event:
-                    try:
+                    with suppress(Exception):
                         on_event(e)
-                    except Exception:
-                        pass
 
             # Status
             job = await self.get_job(job_id)
@@ -115,7 +162,9 @@ class LearningClient:
                 raise TimeoutError(f"Polling timed out after {elapsed} seconds for job {job_id}")
 
     # --- Optional diagnostics ---
-    async def pricing_preflight(self, *, job_type: str, gpu_type: str, estimated_seconds: float, container_count: int) -> Dict[str, Any]:
+    async def pricing_preflight(
+        self, *, job_type: str, gpu_type: str, estimated_seconds: float, container_count: int
+    ) -> dict[str, Any]:
         body = {
             "job_type": job_type,
             "gpu_type": gpu_type,
@@ -125,17 +174,62 @@ class LearningClient:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             js = await http.post_json("/api/v1/pricing/preflight", json=body)
         if not isinstance(js, dict):
-            raise HTTPError(status=500, url="/api/v1/pricing/preflight", message="invalid_preflight_response", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500,
+                url="/api/v1/pricing/preflight",
+                message="invalid_preflight_response",
+                body_snippet=str(js)[:200],
+            )
         return js
 
-    async def balance_autumn_normalized(self) -> Dict[str, Any]:
+    async def balance_autumn_normalized(self) -> dict[str, Any]:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             js = await http.get("/api/v1/balance/autumn-normalized")
         if not isinstance(js, dict):
-            raise HTTPError(status=500, url="/api/v1/balance/autumn-normalized", message="invalid_balance_response", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500,
+                url="/api/v1/balance/autumn-normalized",
+                message="invalid_balance_response",
+                body_snippet=str(js)[:200],
+            )
         return js
 
 
+class FineTunedModelInfo(TypedDict, total=False):
+    id: str
+    base_model: str | None
+    created_at: int | None
+    job_id: str | None
+    status: str | None
+
+
+class LearningClient(LearningClient):  # type: ignore[misc]
+    async def list_fine_tuned_models(self) -> list[FineTunedModelInfo]:
+        """Return completed fine‑tuned models for the caller's organization.
+
+        Calls backend route `/api/learning/models` and returns a compact list.
+        """
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            js = await http.get("/api/learning/models")
+        if isinstance(js, dict) and isinstance(js.get("data"), list):
+            out: list[FineTunedModelInfo] = []
+            for item in js["data"]:
+                if not isinstance(item, dict):
+                    continue
+                rec: FineTunedModelInfo = {
+                    "id": str(item.get("id")),
+                    "base_model": item.get("base_model"),
+                    "created_at": item.get("created_at"),
+                    "job_id": item.get("job_id"),
+                    "status": item.get("status"),
+                }
+                if rec.get("id"):
+                    out.append(rec)
+            return out
+        # Fallback: empty list on unexpected shape
+        return []
+
+
 def _infer_content_type(filename: str) -> str:
     name = filename.lower()
     if name.endswith(".jsonl"):
@@ -145,5 +239,3 @@ def _infer_content_type(filename: str) -> str:
     if name.endswith(".txt"):
         return "text/plain"
     return "application/octet-stream"
-
-

synth_ai/learning/config.py

@@ -1,43 +1,5 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, Dict, Optional
-
-
-@dataclass
-class FTJobConfig:
-    model: str
-    training_file_id: str
-    n_epochs: int = 1
-    batch_size: int = 1
-    upload_to_wasabi: bool = True
-
-    def hyperparameters(self) -> Dict[str, Any]:
-        if self.n_epochs < 1:
-            raise ValueError("n_epochs must be >= 1")
-        if self.batch_size < 1:
-            raise ValueError("batch_size must be >= 1")
-        return {"n_epochs": int(self.n_epochs), "batch_size": int(self.batch_size)}
-
-    def metadata(self) -> Dict[str, Any]:  # type: ignore[override]
-        return {"upload_to_wasabi": bool(self.upload_to_wasabi)}
-
-
-@dataclass
-class RLJobConfig:
-    model: str
-    task_app_url: str
-    trainer_id: str
-    batch_size: int = 1
-    group_size: int = 2
-    job_config_id: Optional[str] = None
-    inline_config: Optional[Dict[str, Any]] = None
-
-    def trainer_dict(self) -> Dict[str, Any]:
-        if self.batch_size < 1:
-            raise ValueError("batch_size must be >= 1")
-        if self.group_size < 2:
-            raise ValueError("group_size must be >= 2")
-        return {"batch_size": int(self.batch_size), "group_size": int(self.group_size)}
-
+from .rl.config import RLJobConfig
 
+__all__ = ["RLJobConfig"]

synth_ai/learning/constants.py

@@ -25,5 +25,3 @@ TERMINAL_EVENT_FAILURE = {
     "rl.job.failed",
     "workflow.failed",
 }
-
-

synth_ai/learning/ft_client.py

@@ -1,59 +1,7 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from ..http import AsyncHttpClient, HTTPError
-
-
-class FtClient:
-    def __init__(self, base_url: str, api_key: str, *, timeout: float = 30.0) -> None:
-        self._base_url = base_url.rstrip("/")
-        self._api_key = api_key
-        self._timeout = timeout
+"""Backward-compatible shim for FtClient (moved to synth_ai.learning.sft.client)."""
 
-    async def upload_training_file(self, path: str | Path, *, purpose: str = "fine-tune") -> str:
-        p = Path(path)
-        content = p.read_bytes()
-        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
-            data = {"purpose": purpose}
-            files = {"file": (p.name, content, _infer_content_type(p.name))}
-            js = await http.post_multipart("/api/learning/files", data=data, files=files)
-        if not isinstance(js, dict) or "id" not in js:
-            raise HTTPError(status=500, url="/api/learning/files", message="invalid_upload_response", body_snippet=str(js)[:200])
-        return str(js["id"])
-
-    async def create_sft_job(
-        self,
-        *,
-        model: str,
-        training_file_id: str,
-        hyperparameters: Dict[str, Any],
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        body = {
-            "training_type": "sft_offline",
-            "model": model,
-            "training_file_id": training_file_id,
-            "hyperparameters": dict(hyperparameters or {}),
-            "metadata": dict(metadata or {}),
-        }
-        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
-            return await http.post_json("/api/learning/jobs", json=body)
-
-    async def start_job(self, job_id: str) -> Dict[str, Any]:
-        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
-            return await http.post_json(f"/api/learning/jobs/{job_id}/start", json={})
-
-
-def _infer_content_type(filename: str) -> str:
-    name = filename.lower()
-    if name.endswith(".jsonl"):
-        return "application/jsonl"
-    if name.endswith(".json"):
-        return "application/json"
-    if name.endswith(".txt"):
-        return "text/plain"
-    return "application/octet-stream"
+from __future__ import annotations
 
+from .sft.client import FtClient
 
+__all__ = ["FtClient"]

synth_ai/learning/health.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Optional
-import aiohttp
+from typing import Any
 
-from ..http import AsyncHttpClient
+from .._utils.http import AsyncHttpClient
 
 
 def _api_base(b: str) -> str:
@@ -11,20 +10,28 @@ def _api_base(b: str) -> str:
     return b if b.endswith("/api") else f"{b}/api"
 
 
-async def backend_health(base_url: str, api_key: str) -> Dict[str, Any]:
+async def backend_health(base_url: str, api_key: str) -> dict[str, Any]:
     async with AsyncHttpClient(base_url, api_key, timeout=15.0) as http:
         js = await http.get(f"{_api_base(base_url)}/health")
     return {"ok": True, "raw": js}
 
 
-async def task_app_health(task_app_url: str) -> Dict[str, Any]:
+async def task_app_health(task_app_url: str) -> dict[str, Any]:
     # Delegate to central task module for consistency
     from synth_ai.task.health import task_app_health as _th
 
     return await _th(task_app_url)
 
 
-async def pricing_preflight(base_url: str, api_key: str, *, job_type: str, gpu_type: str, estimated_seconds: float, container_count: int) -> Dict[str, Any]:
+async def pricing_preflight(
+    base_url: str,
+    api_key: str,
+    *,
+    job_type: str,
+    gpu_type: str,
+    estimated_seconds: float,
+    container_count: int,
+) -> dict[str, Any]:
     body = {
         "job_type": job_type,
         "gpu_type": gpu_type,
@@ -36,8 +43,7 @@ async def pricing_preflight(base_url: str, api_key: str, *, job_type: str, gpu_t
     return js if isinstance(js, dict) else {"raw": js}
 
 
-async def balance_autumn_normalized(base_url: str, api_key: str) -> Dict[str, Any]:
+async def balance_autumn_normalized(base_url: str, api_key: str) -> dict[str, Any]:
     async with AsyncHttpClient(base_url, api_key, timeout=30.0) as http:
         js = await http.get(f"{_api_base(base_url)}/v1/balance/autumn-normalized")
     return js if isinstance(js, dict) else {"raw": js}
-

synth_ai/learning/jobs.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, List, Optional
 import time
+from collections.abc import Callable
+from contextlib import suppress
+from typing import Any
 
+from .._utils.http import AsyncHttpClient, sleep
 from .constants import TERMINAL_EVENT_FAILURE, TERMINAL_EVENT_SUCCESS, TERMINAL_STATUSES
-from ..http import AsyncHttpClient, sleep
 
 
 def _api_base(b: str) -> str:
@@ -17,7 +19,7 @@ class JobsApiResolver:
         self._base = _api_base(base_url)
         self._strict = strict
 
-    def status_urls(self, job_id: str) -> List[str]:
+    def status_urls(self, job_id: str) -> list[str]:
         if self._strict:
             return [f"{self._base}/learning/jobs/{job_id}"]
         return [
@@ -26,7 +28,7 @@ class JobsApiResolver:
             f"{self._base}/orchestration/jobs/{job_id}",
         ]
 
-    def events_urls(self, job_id: str, since: int) -> List[str]:
+    def events_urls(self, job_id: str, since: int) -> list[str]:
         if self._strict:
             return [f"{self._base}/learning/jobs/{job_id}/events?since_seq={since}&limit=200"]
         return [
@@ -40,7 +42,15 @@ class JobsApiResolver:
 
 
 class JobHandle:
-    def __init__(self, base_url: str, api_key: str, job_id: str, *, strict: bool = True, timeout: float = 600.0) -> None:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        job_id: str,
+        *,
+        strict: bool = True,
+        timeout: float = 600.0,
+    ) -> None:
         self.base_url = base_url.rstrip("/")
         self.api_key = api_key
         self.job_id = job_id
@@ -54,23 +64,23 @@ class JobHandle:
         max_seconds: float | None = None,
         empty_polls_threshold: int = 5,
         startup_deadline_s: int = 45,
-        on_event: Optional[Callable[[Dict[str, Any]], None]] = None,
-        on_metric: Optional[Callable[[Dict[str, Any]], None]] = None,
-    ) -> Dict[str, Any]:
-        last_seq_by_stream: Dict[str, int] = {}
-        events_job_id: Optional[str] = None
-        last_status: Optional[str] = None
-        last_step_by_name: Dict[str, int] = {}
+        on_event: Callable[[dict[str, Any]], None] | None = None,
+        on_metric: Callable[[dict[str, Any]], None] | None = None,
+    ) -> dict[str, Any]:
+        last_seq_by_stream: dict[str, int] = {}
+        events_job_id: str | None = None
+        last_status: str | None = None
+        last_step_by_name: dict[str, int] = {}
         empty_polls = 0
         saw_any_event = False
         start_t = time.time()
         resolver = JobsApiResolver(self.base_url, strict=self.strict)
-        detected_fine_tuned_model: Optional[str] = None
+        detected_fine_tuned_model: str | None = None
 
         async with AsyncHttpClient(self.base_url, self.api_key, timeout=self.timeout) as http:
             while True:
                 # Status
-                status_data: Optional[Dict[str, Any]] = None
+                status_data: dict[str, Any] | None = None
                 for su in resolver.status_urls(self.job_id):
                     try:
                         status_data = await http.get(su)
@@ -91,10 +101,8 @@ class JobHandle:
                 if status and status != last_status:
                     last_status = status
                     if on_event:
-                        try:
+                        with suppress(Exception):
                             on_event({"type": "job.status", "message": status})
-                        except Exception:
-                            pass
 
                 # Events
                 stream_ids = [self.job_id]
@@ -102,7 +110,7 @@ class JobHandle:
                     stream_ids.append(events_job_id)
                 total_events_this_cycle = 0
                 terminal_event_seen = False
-                terminal_event_status: Optional[str] = None
+                terminal_event_status: str | None = None
                 for ev_id in stream_ids:
                     since = last_seq_by_stream.get(ev_id, 0)
                     for eu in resolver.events_urls(ev_id, since):
@@ -110,11 +118,8 @@ class JobHandle:
                             ev_js = await http.get(eu)
                         except Exception:
                             continue
-                        try:
-                            events = (ev_js or {}).get("events") or (ev_js or {}).get("data") or []
-                            if not isinstance(events, list):
-                                events = []
-                        except Exception:
+                        events = (ev_js or {}).get("events") or (ev_js or {}).get("data") or []
+                        if not isinstance(events, list):
                             events = []
                         total_events_this_cycle += len(events)
                         if events:
@@ -125,20 +130,16 @@ class JobHandle:
                                 continue
                             last_seq_by_stream[ev_id] = seq_val
                             if on_event:
-                                try:
+                                with suppress(Exception):
                                     on_event(e)
-                                except Exception:
-                                    pass
                             et = str(e.get("type") or e.get("event_type") or "").lower()
                             # Capture fine_tuned_model from event data when available
                             if not detected_fine_tuned_model:
-                                try:
-                                    data_obj = e.get("data") or {}
-                                    ftm = data_obj.get("fine_tuned_model") if isinstance(data_obj, dict) else None
+                                data_obj = e.get("data") or {}
+                                if isinstance(data_obj, dict):
+                                    ftm = data_obj.get("fine_tuned_model")
                                     if isinstance(ftm, str) and ftm:
                                         detected_fine_tuned_model = ftm
-                                except Exception:
-                                    pass
                             if et in TERMINAL_EVENT_SUCCESS:
                                 terminal_event_seen = True
                                 terminal_event_status = "succeeded"
@@ -158,10 +159,8 @@ class JobHandle:
                             continue
                         last_step_by_name[name] = step
                         if on_metric:
-                            try:
+                            with suppress(Exception):
                                 on_metric(p)
-                            except Exception:
-                                pass
                 except Exception:
                     pass
 
@@ -169,20 +168,17 @@ class JobHandle:
                 if terminal_event_seen or (status and status in TERMINAL_STATUSES):
                     # Best-effort enrichment of final result with fine_tuned_model
                     result_status = terminal_event_status or status or "completed"
-                    final_res: Dict[str, Any] = {"status": result_status, "job_id": self.job_id}
+                    final_res: dict[str, Any] = {"status": result_status, "job_id": self.job_id}
                     if not detected_fine_tuned_model:
                         # Briefly try to re-fetch status to see if fine_tuned_model is persisted
                         try:
                             for su in resolver.status_urls(self.job_id):
-                                try:
-                                    final_status = await http.get(su)
-                                    if isinstance(final_status, dict):
-                                        ftm2 = final_status.get("fine_tuned_model")
-                                        if isinstance(ftm2, str) and ftm2:
-                                            detected_fine_tuned_model = ftm2
-                                            break
-                                except Exception:
-                                    continue
+                                final_status = await http.get(su)
+                                if isinstance(final_status, dict):
+                                    ftm2 = final_status.get("fine_tuned_model")
+                                    if isinstance(ftm2, str) and ftm2:
+                                        detected_fine_tuned_model = ftm2
+                                        break
                         except Exception:
                             pass
                     if detected_fine_tuned_model:
@@ -200,6 +196,6 @@ class JobHandle:
                     )
                 await sleep(interval_seconds)
                 if max_seconds is not None and (time.time() - start_t) >= max_seconds:
-                    raise TimeoutError(f"Polling timed out after {max_seconds}s for job {self.job_id}")
-
-
+                    raise TimeoutError(
+                        f"Polling timed out after {max_seconds}s for job {self.job_id}"
+                    )