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

synth_ai/v0/tracing_v1/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_v1/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_v1/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)

synth_ai/v0/tracing_v1/config.py

@@ -1,142 +0,0 @@
-import json
-from collections.abc import Sequence
-from enum import Enum
-from typing import Any, NotRequired, TypedDict
-
-from opentelemetry import trace
-from opentelemetry.sdk.trace import ReadableSpan, TracerProvider
-from opentelemetry.sdk.trace.export import (
-    SimpleSpanProcessor,
-    SpanExporter,
-    SpanExportResult,
-)
-from pydantic import BaseModel, ConfigDict, Field
-
-from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT
-
-
-class InMemoryExporter(SpanExporter):
-    def __init__(self):
-        self.spans: list[dict[str, Any]] = []
-
-    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
-        for span in spans:
-            self.spans.append(
-                {
-                    "name": span.name,
-                    "context": {
-                        "trace_id": span.context.trace_id,
-                        "span_id": span.context.span_id,
-                    },
-                    "parent_id": span.parent.span_id if span.parent else None,
-                    "start_time": span.start_time,
-                    "end_time": span.end_time,
-                    "attributes": dict(span.attributes),
-                    "events": [
-                        {
-                            "name": event.name,
-                            "timestamp": event.timestamp,
-                            "attributes": dict(event.attributes),
-                        }
-                        for event in span.events
-                    ],
-                }
-            )
-        return SpanExportResult.SUCCESS
-
-    def shutdown(self):
-        pass
-
-    def get_spans(self) -> list[dict[str, Any]]:
-        return self.spans
-
-    def clear(self):
-        self.spans = []
-
-    def to_json(self) -> str:
-        return json.dumps(self.spans, default=str)
-
-
-# Initialize the custom exporter
-in_memory_exporter = InMemoryExporter()
-
-# Set up the tracer provider
-tracer_provider = TracerProvider()
-span_processor = SimpleSpanProcessor(
-    in_memory_exporter
-)  # Use SimpleSpanProcessor for immediate exporting
-tracer_provider.add_span_processor(span_processor)
-trace.set_tracer_provider(tracer_provider)
-
-# Get a tracer
-tracer = trace.get_tracer(__name__)
-
-
-def shutdown_tracer_provider():
-    tracer_provider.shutdown()
-
-
-# Valid types for tracking
-VALID_TYPES = (str, dict, int, float, bool, list, type(None), BaseModel)
-
-
-class LoggingMode(Enum):
-    INSTANT = "instant"
-    DEFERRED = "deferred"
-
-
-class Origin(str, Enum):
-    """Source of computation in the system."""
-
-    AGENT = "agent"
-    ENVIRONMENT = "environment"
-
-
-class EventManagement(str, Enum):
-    """Controls the lifecycle of trace events."""
-
-    CREATE = "create"
-    END = "end"
-    CREATE_AND_END = "create_and_end"
-
-
-class TracingConfig(BaseModel):
-    mode: LoggingMode = Field(default=LoggingMode.DEFERRED)
-    api_key: str
-    base_url: str = Field(default=PROD_BASE_URL_DEFAULT)
-    max_retries: int = Field(default=3)
-    retry_backoff: float = Field(default=1.5)  # exponential backoff multiplier
-    batch_size: int = Field(default=1)  # for future batching support
-    timeout: float = Field(default=5.0)  # seconds
-    sdk_version: str = Field(default="0.1.0")  # Added sdk_version field
-
-    # Connection settings
-    max_connections: int = Field(
-        default=100, gt=0, description="Maximum number of concurrent connections"
-    )
-    keepalive_expiry: float = Field(
-        default=30.0, gt=0, description="Connection keepalive time in seconds"
-    )
-
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")  # Prevent additional fields
-
-
-class Message(TypedDict):
-    """A message in a conversation with an AI model."""
-
-    role: str
-    content: str
-    name: NotRequired[str]
-    function_call: NotRequired[dict[str, str]]
-
-
-class ModelParams(TypedDict, total=False):
-    """Parameters for configuring model behavior."""
-
-    temperature: float
-    max_tokens: int
-    top_p: float
-    frequency_penalty: float
-    presence_penalty: float
-    stop: str | list[str]
-    functions: list[dict[str, Any]]