synth-ai 0.1.9__py3-none-any.whl → 0.2.1.dev0__py3-none-any.whl

synth_ai/{zyk/lms → lm}/vendors/supported/together.py

@@ -2,7 +2,7 @@ import os
 
 from together import AsyncTogether, Together
 
-from synth_ai.zyk.lms.vendors.openai_standard import OpenAIStandard
+from synth_ai.lm.vendors.openai_standard import OpenAIStandard
 
 
 class TogetherAPI(OpenAIStandard):

synth_ai/tracing/abstractions.py

@@ -0,0 +1,224 @@
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+
+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: Optional[str] = None
+    model_params: Optional[Dict[str, Any]] = None
+    should_learn: Optional[bool] = None
+    compute_input: List[Union[MessageInputs, ArbitraryInputs]]
+    compute_output: List[Union[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: Optional[float]
+    partition_index: int
+    agent_compute_step: AgentComputeStep
+    environment_compute_steps: List["EnvironmentComputeStep"]
+    system_name: Optional[str] = None
+    system_id: Optional[str] = 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: Optional[Dict[str, Any]] = 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: Union[float, int, bool]
+    annotation: Optional[str] = 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/tracing/base_client.py

@@ -0,0 +1,91 @@
+import logging
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from synth_ai.tracing.abstractions import Event
+from synth_ai.tracing.config import TracingConfig
+from synth_ai.tracing.events.store import event_store
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LogResponse:
+    """Represents the response from a logging attempt"""
+
+    success: bool
+    error: Optional[str] = None
+    retry_after: Optional[float] = None
+    status_code: Optional[int] = 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: Optional[int] = 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/tracing/client_manager.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import asyncio
+import random
+from typing import ClassVar, Dict, Optional
+
+import httpx
+
+from synth_ai.tracing.config import TracingConfig
+
+
+class ClientManager:
+    """Singleton manager for HTTP clients with both sync and async support"""
+
+    _instance: ClassVar[Optional[ClientManager]] = None
+    _lock = asyncio.Lock()
+
+    def __init__(self):
+        self._config: Optional[TracingConfig] = None
+        self._sync_client: Optional[httpx.Client] = None
+        self._async_client: Optional[httpx.AsyncClient] = 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) -> Optional[TracingConfig]:
+        """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/tracing/config.py

@@ -0,0 +1,140 @@
+import json
+from enum import Enum
+from typing import Any, Dict, List, Sequence, TypedDict, Union
+
+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 typing_extensions import NotRequired
+
+
+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="https://agent-learning.onrender.com")
+    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: Union[str, List[str]]
+    functions: List[Dict[str, Any]]