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

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]]

synth_ai/v0/tracing_v1/context.py

@@ -1,146 +0,0 @@
-import asyncio
-import logging
-from contextlib import contextmanager
-from typing import Any, Generic, TypeVar
-
-from .local import (
-    _local,
-    active_events_var,
-    system_id_var,
-    system_instance_id_var,
-    system_instance_metadata_var,
-    system_name_var,
-)
-
-logger = logging.getLogger(__name__)
-
-T = TypeVar("T")
-
-
-class ContextState(Generic[T]):
-    """Manages state that needs to be accessible in both sync and async contexts."""
-
-    def __init__(self, thread_local_attr: str, context_var: T):
-        self.thread_local_attr = thread_local_attr
-        self.context_var = context_var
-
-    def get(self) -> T | None:
-        """Get value from appropriate context."""
-        try:
-            asyncio.get_running_loop()
-            return self.context_var.get() or getattr(_local, self.thread_local_attr, None)
-        except RuntimeError:
-            return getattr(_local, self.thread_local_attr, None)
-
-    def set(self, value: T) -> T | None:
-        """Set value in appropriate context."""
-        try:
-            asyncio.get_running_loop()
-            return self.context_var.set(value)
-        except RuntimeError:
-            setattr(_local, self.thread_local_attr, value)
-            return None
-
-    def reset(self, token: T | None = None) -> None:
-        """Reset/clear value from appropriate context."""
-        try:
-            asyncio.get_running_loop()
-            if token is not None:
-                self.context_var.reset(token)
-            else:
-                self.context_var.set(None)
-        except RuntimeError:
-            if hasattr(_local, self.thread_local_attr):
-                delattr(_local, self.thread_local_attr)
-
-
-# Create global context state managers
-system_name_state = ContextState("system_name", system_name_var)
-system_id_state = ContextState("system_id", system_id_var)
-system_instance_id_state = ContextState("system_instance_id", system_instance_id_var)
-system_instance_metadata_state = ContextState(
-    "system_instance_metadata", system_instance_metadata_var
-)
-active_events_state = ContextState("active_events", active_events_var)
-
-
-@contextmanager
-def trace_context(
-    system_name: str,
-    system_id: str,
-    system_instance_id: str,
-    system_instance_metadata: dict[str, Any] | None = None,
-):
-    """Context manager for setting up tracing context.
-
-    This ensures proper setup and cleanup of context variables in both sync and async code.
-    Also handles nested decorators by preserving existing context if present.
-
-    Args:
-        system_name: Name of the system
-        system_id: ID of the system
-        system_instance_id: Instance ID of the system
-        system_instance_metadata: Optional metadata for the system instance
-    """
-    # Store existing context if any
-    prev_system_name = system_name_state.get()
-    prev_system_id = system_id_state.get()
-    prev_system_instance_id = system_instance_id_state.get()
-    prev_system_instance_metadata = system_instance_metadata_state.get()
-    prev_active_events = active_events_state.get()
-
-    try:
-        # Set new context
-        system_name_token = system_name_state.set(system_name)
-        system_id_token = system_id_state.set(system_id)
-        system_instance_id_token = system_instance_id_state.set(system_instance_id)
-
-        # Set system_instance_metadata if provided, otherwise use empty dict
-        metadata_to_set = system_instance_metadata if system_instance_metadata is not None else {}
-        system_instance_metadata_token = system_instance_metadata_state.set(metadata_to_set)
-
-        # Initialize active events if not present
-        if not active_events_state.get():
-            active_events_state.set({})
-
-        yield
-    finally:
-        # Restore previous context if it existed
-        if prev_system_name is not None:
-            system_name_state.set(prev_system_name)
-        else:
-            system_name_state.reset(system_name_token)
-
-        if prev_system_id is not None:
-            system_id_state.set(prev_system_id)
-        else:
-            system_id_state.reset(system_id_token)
-
-        if prev_system_instance_id is not None:
-            system_instance_id_state.set(prev_system_instance_id)
-        else:
-            system_instance_id_state.reset(system_instance_id_token)
-
-        if prev_system_instance_metadata is not None:
-            system_instance_metadata_state.set(prev_system_instance_metadata)
-        else:
-            system_instance_metadata_state.reset(system_instance_metadata_token)
-
-        if prev_active_events is not None:
-            active_events_state.set(prev_active_events)
-        else:
-            active_events_state.reset()
-
-
-def get_current_context() -> dict[str, Any]:
-    """Get the current tracing context.
-
-    Returns:
-        Dict containing current system_name, system_id, system_instance_id, and system_instance_metadata
-    """
-    return {
-        "system_name": system_name_state.get(),
-        "system_id": system_id_state.get(),
-        "system_instance_id": system_instance_id_state.get(),
-        "system_instance_metadata": system_instance_metadata_state.get() or {},
-    }