synth-ai 0.2.14__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/v0/lm/warmup.py

@@ -1,186 +0,0 @@
-"""
-Model warmup utilities for Synth backend.
-Handles model preloading and warmup polling.
-"""
-
-import asyncio
-import logging
-import sys
-import time
-from datetime import datetime, timedelta
-
-import httpx
-
-from .config import SynthConfig
-
-logger = logging.getLogger(__name__)
-
-
-class WarmupStatus:
-    """Track warmup status for models with TTL."""
-
-    def __init__(self):
-        self._warmed_models: dict[str, datetime] = {}
-        self._ttl = timedelta(minutes=10)  # Consider models warm for 10 minutes
-
-    def is_warm(self, model_name: str) -> bool:
-        """Check if model is already warmed up."""
-        if model_name in self._warmed_models:
-            if datetime.now() - self._warmed_models[model_name] < self._ttl:
-                return True
-            else:
-                # Clean up expired entry
-                del self._warmed_models[model_name]
-        return False
-
-    def mark_warm(self, model_name: str):
-        """Mark model as warmed up."""
-        self._warmed_models[model_name] = datetime.now()
-
-    def clear(self):
-        """Clear all warmup status."""
-        self._warmed_models.clear()
-
-
-# Global warmup tracker
-_warmup_status = WarmupStatus()
-
-
-async def warmup_synth_model(
-    model_name: str,
-    config: SynthConfig | None = None,
-    max_attempts: int | None = None,
-    force: bool = False,
-    verbose: bool = True,
-    gpu_preference: str | None = None,
-) -> bool:
-    """
-    Warm up a model on the Synth backend using fire-and-forget approach.
-
-    Args:
-        model_name: Name of the model to warm up
-        config: Synth configuration (loads from env if not provided)
-        max_attempts: Maximum number of polling attempts
-        force: Force warmup even if model is cached as warm
-        verbose: Print progress messages
-
-    Returns:
-        True if model is successfully warmed up, False otherwise
-    """
-    # Load config from environment if not provided
-    if config is None:
-        config = SynthConfig.from_env()
-
-    # Check if already warm
-    if not force and _warmup_status.is_warm(model_name):
-        return True
-
-    async with httpx.AsyncClient() as client:
-        headers = {"Authorization": f"Bearer {config.api_key}"}
-        if gpu_preference:
-            headers["X-GPU-Preference"] = gpu_preference
-
-        # Step 1: Start warmup (fire and forget)
-        try:
-            response = await client.post(
-                f"{config.get_base_url_without_v1()}/warmup/{model_name}",
-                headers=headers,
-                timeout=30.0,  # Short timeout for the start request
-            )
-
-            if response.status_code == 200:
-                response_data = response.json()
-                if response_data.get("status") in ["warming", "already_warming"]:
-                    pass
-                elif response_data.get("status") == "already_warmed":
-                    _warmup_status.mark_warm(model_name)
-                    return True
-                else:
-                    logger.warning(f"Unexpected warmup response: {response_data}")
-            else:
-                logger.warning(
-                    f"Warmup start failed with status {response.status_code}: {response.text}"
-                )
-                return False
-
-        except Exception as e:
-            logger.warning(f"Warmup start failed: {e}")
-            return False
-
-        # Step 2: Poll status until ready (indefinite by default)
-        spinner = "|/-\\"
-        spin_idx = 0
-        start_time = time.time()
-        attempt = 0
-        while True:
-            attempt += 1
-            try:
-                response = await client.get(
-                    f"{config.get_base_url_without_v1()}/warmup/status/{model_name}",
-                    headers=headers,
-                    timeout=10.0,
-                )
-
-                if response.status_code == 200:
-                    status_data = response.json()
-                    status = status_data.get("status")
-
-                    if status == "warmed":
-                        _warmup_status.mark_warm(model_name)
-                        # Final spinner line as success
-                        elapsed = int(time.time() - start_time)
-                        sys.stdout.write(f"\r✅ Warmed {model_name} in {elapsed}s        \n")
-                        sys.stdout.flush()
-                        return True
-                    elif status == "failed":
-                        error = status_data.get("error", "Unknown error")
-                        logger.error(f"❌ Warmup failed for {model_name}: {error}")
-                        sys.stdout.write(f"\r❌ Warmup failed: {error}            \n")
-                        sys.stdout.flush()
-                        return False
-                    else:
-                        # Treat unknown statuses (e.g., "cold") as still warming
-                        elapsed = int(time.time() - start_time)
-                        wheel = spinner[spin_idx % len(spinner)]
-                        spin_idx += 1
-                        label = status or "pending"
-                        sys.stdout.write(
-                            f"\r⏳ Warming {model_name} [{wheel}] status={label} elapsed={elapsed}s"
-                        )
-                        sys.stdout.flush()
-
-                # Short sleep between status checks
-                await asyncio.sleep(2.0)
-
-            except httpx.TimeoutException:
-                # Continue polling; update spinner line
-                elapsed = int(time.time() - start_time)
-                wheel = spinner[spin_idx % len(spinner)]
-                spin_idx += 1
-                sys.stdout.write(
-                    f"\r⏳ Warming {model_name} [{wheel}] status=timeout elapsed={elapsed}s"
-                )
-                sys.stdout.flush()
-                await asyncio.sleep(1.0)
-            except Exception:
-                # Continue polling; update spinner line with error label
-                elapsed = int(time.time() - start_time)
-                wheel = spinner[spin_idx % len(spinner)]
-                spin_idx += 1
-                sys.stdout.write(
-                    f"\r⏳ Warming {model_name} [{wheel}] status=error elapsed={elapsed}s"
-                )
-                sys.stdout.flush()
-                await asyncio.sleep(1.0)
-
-            # Optional max_attempts for callers who want a cap
-            if max_attempts is not None and attempt >= max_attempts:
-                logger.error(f"Failed to warm up {model_name} after {max_attempts} status checks")
-                sys.stdout.write("\n")
-                sys.stdout.flush()
-                return False
-
-
-def get_warmup_status() -> WarmupStatus:
-    """Get the global warmup status tracker."""
-    return _warmup_status

synth_ai/v0/tracing/abstractions.py

@@ -1,224 +0,0 @@
-import logging
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any
-
-from pydantic import BaseModel
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class MessageInputs:
-    messages: list[dict[str, str]]  # {"role": "", "content": ""}
-
-
-@dataclass
-class ArbitraryInputs:
-    inputs: dict[str, Any]
-
-
-@dataclass
-class MessageOutputs:
-    messages: list[dict[str, str]]
-
-
-@dataclass
-class ArbitraryOutputs:
-    outputs: dict[str, Any]
-
-
-@dataclass
-class ComputeStep:
-    event_order: int
-    compute_ended: datetime  # time step
-    compute_began: datetime  # time step
-    compute_input: dict[str, Any]  # {variable_name: value}
-    compute_output: dict[str, Any]  # {variable_name: value}
-
-    def to_dict(self):
-        # Serialize compute_input
-        serializable_input = [
-            input_item.__dict__
-            for input_item in self.compute_input
-            if isinstance(input_item, (MessageInputs, ArbitraryInputs))
-        ]
-
-        # Serialize compute_output
-        serializable_output = [
-            output_item.__dict__
-            for output_item in self.compute_output
-            if isinstance(output_item, (MessageOutputs, ArbitraryOutputs))
-        ]
-
-        # Warn about non-serializable inputs/outputs
-        for item in self.compute_input:
-            if not isinstance(item, (MessageInputs, ArbitraryInputs)):
-                logger.warning(f"Skipping non-serializable input: {item}")
-        for item in self.compute_output:
-            if not isinstance(item, (MessageOutputs, ArbitraryOutputs)):
-                logger.warning(f"Skipping non-serializable output: {item}")
-
-        return {
-            "event_order": self.event_order,
-            "compute_ended": self.compute_ended.isoformat()
-            if isinstance(self.compute_ended, datetime)
-            else self.compute_ended,
-            "compute_began": self.compute_began.isoformat()
-            if isinstance(self.compute_began, datetime)
-            else self.compute_began,
-            "compute_input": serializable_input,
-            "compute_output": serializable_output,
-        }
-
-
-@dataclass
-class AgentComputeStep(ComputeStep):
-    model_name: str | None = None
-    model_params: dict[str, Any] | None = None
-    should_learn: bool | None = None
-    compute_input: list[MessageInputs | ArbitraryInputs]
-    compute_output: list[MessageOutputs | ArbitraryOutputs]
-
-    def to_dict(self):
-        base_dict = super().to_dict()  # Get the parent class serialization
-        base_dict["model_name"] = self.model_name  # Add model_name
-        return base_dict
-
-
-@dataclass
-class EnvironmentComputeStep(ComputeStep):
-    compute_input: list[ArbitraryInputs]
-    compute_output: list[ArbitraryOutputs]
-
-
-@dataclass
-class Event:
-    system_instance_id: str
-    event_type: str
-    opened: float
-    closed: float | None
-    partition_index: int
-    agent_compute_step: AgentComputeStep
-    environment_compute_steps: list["EnvironmentComputeStep"]
-    system_name: str | None = None
-    system_id: str | None = None
-    event_metadata: dict[str, Any] = None  # JSON-serializable metadata for this specific event
-
-    def __post_init__(self):
-        if self.event_metadata is None:
-            self.event_metadata = {}
-
-    def to_dict(self):
-        return {
-            "event_type": self.event_type,
-            "opened": self.opened.isoformat() if isinstance(self.opened, datetime) else self.opened,
-            "closed": self.closed.isoformat() if isinstance(self.closed, datetime) else self.closed,
-            "partition_index": self.partition_index,
-            "agent_compute_step": self.agent_compute_step.to_dict()
-            if self.agent_compute_step
-            else None,
-            "environment_compute_steps": [
-                step.to_dict() for step in self.environment_compute_steps
-            ],
-            "event_metadata": self.event_metadata,
-        }
-
-    # backwards compatibility
-    @property
-    def agent_compute_steps(self) -> list[AgentComputeStep]:
-        """Backwards compatibility method that returns a list containing the agent_compute_step."""
-        return [self.agent_compute_step] if self.agent_compute_step is not None else []
-
-
-@dataclass
-class EventPartitionElement:
-    partition_index: int
-    events: list[Event]
-
-    def to_dict(self):
-        return {
-            "partition_index": self.partition_index,
-            "events": [event.to_dict() for event in self.events],
-        }
-
-
-@dataclass
-class SystemTrace:
-    system_name: str
-    system_id: str
-    system_instance_id: str
-    partition: list[EventPartitionElement]
-    metadata: dict[str, Any] | None = None  # System-level metadata
-    instance_metadata: dict[str, Any] = (
-        None  # JSON-serializable metadata for this specific instance
-    )
-    current_partition_index: int = 0  # Track current partition
-
-    def __post_init__(self):
-        if self.instance_metadata is None:
-            self.instance_metadata = {}
-
-    def to_dict(self):
-        return {
-            "system_name": self.system_name,
-            "system_id": self.system_id,
-            "system_instance_id": self.system_instance_id,
-            "partition": [element.to_dict() for element in self.partition],
-            "current_partition_index": self.current_partition_index,
-            "metadata": self.metadata if self.metadata else None,
-            "instance_metadata": self.instance_metadata,
-        }
-
-
-class TrainingQuestion(BaseModel):
-    """
-    A training question is a question that an agent (system_instance_id) is trying to answer.
-    It contains an intent and criteria that the agent is trying to meet.
-    """
-
-    id: str
-    intent: str
-    criteria: str
-
-    def to_dict(self):
-        return {
-            "id": self.id,
-            "intent": self.intent,
-            "criteria": self.criteria,
-        }
-
-
-class RewardSignal(BaseModel):
-    """
-    A reward signal tells us how well an agent (system_instance_id) is doing on a particular question (question_id).
-    """
-
-    question_id: str
-    system_instance_id: str
-    reward: float | int | bool
-    annotation: str | None = None
-
-    def to_dict(self):
-        return {
-            "question_id": self.question_id,
-            "system_instance_id": self.system_instance_id,
-            "reward": self.reward,
-            "annotation": self.annotation,
-        }
-
-
-class Dataset(BaseModel):
-    """
-    A dataset is a collection of training questions and reward signals.
-    This better represents the data that is used to train a model, and gives us more information about the data.
-    """
-
-    questions: list[TrainingQuestion]
-    reward_signals: list[RewardSignal]
-
-    def to_dict(self):
-        return {
-            "questions": [question.to_dict() for question in self.questions],
-            "reward_signals": [signal.to_dict() for signal in self.reward_signals],
-        }

synth_ai/v0/tracing/base_client.py

@@ -1,91 +0,0 @@
-import logging
-import time
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Any
-
-from .abstractions import Event
-from .config import TracingConfig
-from .events.store import event_store
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class LogResponse:
-    """Represents the response from a logging attempt"""
-
-    success: bool
-    error: str | None = None
-    retry_after: float | None = None
-    status_code: int | None = None
-
-
-class BaseLogClient(ABC):
-    """Abstract base class for logging clients"""
-
-    def __init__(self, config: TracingConfig):
-        self.config = config
-        self._consecutive_failures = 0
-        self._last_failure_time = 0
-        self._circuit_open = False
-        self._circuit_open_time = 0
-
-    def _should_retry(self, attempt: int, status_code: int | None = None) -> bool:
-        """Determine if a retry should be attempted based on configuration and status"""
-        if attempt >= self.config.max_retries:
-            return False
-
-        # Don't retry on certain status codes
-        if status_code:
-            # Always retry on 429 (Too Many Requests)
-            if status_code == 429:
-                return True
-
-            # Don't retry on client errors except timeout/too many requests
-            if 400 <= status_code < 500 and status_code not in (408, 429):
-                return False
-
-        return True
-
-    def _prepare_payload(self, event: Event, system_info: dict[str, str]) -> dict[str, Any]:
-        """Prepare the payload for sending"""
-        return {
-            "event": event.to_dict(),
-            "system_info": system_info,
-            "timestamp": time.time(),
-            "sdk_version": self.config.sdk_version,  # Use SDK version from config
-        }
-
-    def _handle_failure(self, event: Event, system_info: dict[str, str], error: Exception) -> None:
-        """Handle logging failure by storing in event_store"""
-        logger.error(f"Logging failed: {str(error)}")
-        self._consecutive_failures += 1
-        self._last_failure_time = time.time()
-
-        # Store in event_store as backup
-        event_store.add_event(
-            system_info["system_name"],
-            system_info["system_id"],
-            system_info["system_instance_id"],
-            event,
-        )
-
-    def _handle_success(self) -> None:
-        """Handle successful logging attempt"""
-        self._consecutive_failures = 0
-        self._last_failure_time = 0
-
-    @abstractmethod
-    def send_event(self, event: Event, system_info: dict[str, str]) -> bool:
-        """Send a single event with retries and fallback"""
-        pass
-
-
-class BaseAsyncLogClient(BaseLogClient):
-    """Abstract base class for async logging clients"""
-
-    @abstractmethod
-    async def send_event(self, event: Event, system_info: dict[str, str]) -> bool:
-        """Send a single event with retries and fallback (async version)"""
-        pass

synth_ai/v0/tracing/client_manager.py

@@ -1,131 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import random
-from typing import ClassVar
-
-import httpx
-
-from .config import TracingConfig
-
-
-class ClientManager:
-    """Singleton manager for HTTP clients with both sync and async support"""
-
-    _instance: ClassVar[ClientManager | None] = None
-    _lock = asyncio.Lock()
-
-    def __init__(self):
-        self._config: TracingConfig | None = None
-        self._sync_client: httpx.Client | None = None
-        self._async_client: httpx.AsyncClient | None = None
-        self._credentials_cache: dict[str, str] = {}
-
-    @classmethod
-    async def get_instance(cls) -> ClientManager:
-        """Get or create the singleton instance asynchronously"""
-        if not cls._instance:
-            async with cls._lock:
-                if not cls._instance:
-                    cls._instance = ClientManager()
-        return cls._instance
-
-    @classmethod
-    def initialize(cls, config: TracingConfig) -> ClientManager:
-        """Initialize or return the singleton instance synchronously"""
-        if cls._instance is None:
-            cls._instance = cls()
-        cls._instance.configure(config)
-        return cls._instance
-
-    def configure(self, config: TracingConfig) -> None:
-        """Configure the client manager with new settings"""
-        self._config = config
-        self._credentials_cache = {
-            "api_key": config.api_key,
-            "api_secret": getattr(config, "api_secret", None),
-        }
-        self._close_clients()
-
-    def get_sync_client(self) -> httpx.Client:
-        """Get or create synchronized HTTP client with connection pooling"""
-        if not self._sync_client and self._config:
-            limits = httpx.Limits(
-                max_connections=self._config.max_connections,
-                max_keepalive_connections=self._config.max_connections,
-            )
-            timeout = httpx.Timeout(timeout=self._config.timeout)
-            self._sync_client = httpx.Client(
-                base_url=self._config.base_url,
-                timeout=timeout,
-                limits=limits,
-                headers={"Authorization": f"Bearer {self._config.api_key}"},
-            )
-        return self._sync_client
-
-    async def get_async_client(self) -> httpx.AsyncClient:
-        """Get or create asynchronous HTTP client with connection pooling"""
-        if not self._async_client and self._config:
-            limits = httpx.Limits(
-                max_connections=self._config.max_connections,
-                max_keepalive_connections=self._config.max_connections,
-            )
-            timeout = httpx.Timeout(timeout=self._config.timeout)
-            self._async_client = httpx.AsyncClient(
-                base_url=self._config.base_url,
-                timeout=timeout,
-                limits=limits,
-                headers={"Authorization": f"Bearer {self._config.api_key}"},
-            )
-        return self._async_client
-
-    def calculate_backoff(self, retry_number: int) -> float:
-        """Calculate backoff time with exponential backoff and jitter"""
-        if not self._config:
-            raise RuntimeError("ClientManager not configured")
-
-        if retry_number <= 0:
-            return 0
-
-        if not getattr(self._config, "retry_exponential_backoff", True):
-            return self._config.retry_backoff
-
-        # Calculate exponential backoff
-        delay = min(
-            self._config.retry_backoff * (2 ** (retry_number - 1)),
-            60.0,  # Cap at 60 seconds
-        )
-
-        # Add jitter (±25% of delay)
-        jitter = delay * 0.25
-        delay = random.uniform(delay - jitter, delay + jitter)
-
-        return max(0.0, delay)
-
-    def close(self) -> None:
-        """Close the sync client"""
-        if self._sync_client:
-            self._sync_client.close()
-            self._sync_client = None
-
-    async def aclose(self) -> None:
-        """Close the async client"""
-        if self._async_client:
-            await self._async_client.aclose()
-            self._async_client = None
-
-    def _close_clients(self) -> None:
-        """Close both sync and async clients"""
-        self.close()
-        if self._async_client:
-            asyncio.create_task(self.aclose())
-
-    @property
-    def config(self) -> TracingConfig | None:
-        """Get the current configuration"""
-        return self._config
-
-    @config.setter
-    def config(self, value: TracingConfig) -> None:
-        """Set the configuration and reset clients"""
-        self.configure(value)