synth-ai 0.2.4.dev5__py3-none-any.whl → 0.2.4.dev7__py3-none-any.whl

synth_ai/v0/tracing/abstractions.py

@@ -1,7 +1,7 @@
 import logging
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -10,22 +10,22 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class MessageInputs:
-    messages: List[Dict[str, str]]  # {"role": "", "content": ""}
+    messages: list[dict[str, str]]  # {"role": "", "content": ""}
 
 
 @dataclass
 class ArbitraryInputs:
-    inputs: Dict[str, Any]
+    inputs: dict[str, Any]
 
 
 @dataclass
 class MessageOutputs:
-    messages: List[Dict[str, str]]
+    messages: list[dict[str, str]]
 
 
 @dataclass
 class ArbitraryOutputs:
-    outputs: Dict[str, Any]
+    outputs: dict[str, Any]
 
 
 @dataclass
@@ -33,8 +33,8 @@ 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}
+    compute_input: dict[str, Any]  # {variable_name: value}
+    compute_output: dict[str, Any]  # {variable_name: value}
 
     def to_dict(self):
         # Serialize compute_input
@@ -74,11 +74,11 @@ class ComputeStep:
 
 @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]]
+    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
@@ -88,8 +88,8 @@ class AgentComputeStep(ComputeStep):
 
 @dataclass
 class EnvironmentComputeStep(ComputeStep):
-    compute_input: List[ArbitraryInputs]
-    compute_output: List[ArbitraryOutputs]
+    compute_input: list[ArbitraryInputs]
+    compute_output: list[ArbitraryOutputs]
 
 
 @dataclass
@@ -97,13 +97,13 @@ class Event:
     system_instance_id: str
     event_type: str
     opened: float
-    closed: Optional[float]
+    closed: float | None
     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
+    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:
@@ -126,7 +126,7 @@ class Event:
 
     # backwards compatibility
     @property
-    def agent_compute_steps(self) -> List[AgentComputeStep]:
+    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 []
 
@@ -134,7 +134,7 @@ class Event:
 @dataclass
 class EventPartitionElement:
     partition_index: int
-    events: List[Event]
+    events: list[Event]
 
     def to_dict(self):
         return {
@@ -148,9 +148,9 @@ 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] = (
+    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
@@ -196,8 +196,8 @@ class RewardSignal(BaseModel):
 
     question_id: str
     system_instance_id: str
-    reward: Union[float, int, bool]
-    annotation: Optional[str] = None
+    reward: float | int | bool
+    annotation: str | None = None
 
     def to_dict(self):
         return {
@@ -214,8 +214,8 @@ class Dataset(BaseModel):
     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]
+    questions: list[TrainingQuestion]
+    reward_signals: list[RewardSignal]
 
     def to_dict(self):
         return {

synth_ai/v0/tracing/base_client.py

@@ -2,7 +2,7 @@ import logging
 import time
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any, Dict, Optional
+from typing import Any
 
 from .abstractions import Event
 from .config import TracingConfig
@@ -16,9 +16,9 @@ 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
+    error: str | None = None
+    retry_after: float | None = None
+    status_code: int | None = None
 
 
 class BaseLogClient(ABC):
@@ -31,7 +31,7 @@ class BaseLogClient(ABC):
         self._circuit_open = False
         self._circuit_open_time = 0
 
-    def _should_retry(self, attempt: int, status_code: Optional[int] = None) -> bool:
+    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
@@ -48,7 +48,7 @@ class BaseLogClient(ABC):
 
         return True
 
-    def _prepare_payload(self, event: Event, system_info: Dict[str, str]) -> Dict[str, Any]:
+    def _prepare_payload(self, event: Event, system_info: dict[str, str]) -> dict[str, Any]:
         """Prepare the payload for sending"""
         return {
             "event": event.to_dict(),
@@ -57,7 +57,7 @@ class BaseLogClient(ABC):
             "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:
+    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
@@ -77,7 +77,7 @@ class BaseLogClient(ABC):
         self._last_failure_time = 0
 
     @abstractmethod
-    def send_event(self, event: Event, system_info: Dict[str, str]) -> bool:
+    def send_event(self, event: Event, system_info: dict[str, str]) -> bool:
         """Send a single event with retries and fallback"""
         pass
 
@@ -86,6 +86,6 @@ class BaseAsyncLogClient(BaseLogClient):
     """Abstract base class for async logging clients"""
 
     @abstractmethod
-    async def send_event(self, event: Event, system_info: Dict[str, str]) -> bool:
+    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

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import random
-from typing import ClassVar, Dict, Optional
+from typing import ClassVar
 
 import httpx
 
@@ -12,14 +12,14 @@ from .config import TracingConfig
 class ClientManager:
     """Singleton manager for HTTP clients with both sync and async support"""
 
-    _instance: ClassVar[Optional[ClientManager]] = None
+    _instance: ClassVar[ClientManager | None] = 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] = {}
+        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:
@@ -121,7 +121,7 @@ class ClientManager:
             asyncio.create_task(self.aclose())
 
     @property
-    def config(self) -> Optional[TracingConfig]:
+    def config(self) -> TracingConfig | None:
         """Get the current configuration"""
         return self._config
 

synth_ai/v0/tracing/config.py

@@ -1,6 +1,7 @@
 import json
+from collections.abc import Sequence
 from enum import Enum
-from typing import Any, Dict, List, Sequence, TypedDict, Union
+from typing import Any, NotRequired, TypedDict
 
 from opentelemetry import trace
 from opentelemetry.sdk.trace import ReadableSpan, TracerProvider
@@ -10,12 +11,11 @@ from opentelemetry.sdk.trace.export import (
     SpanExportResult,
 )
 from pydantic import BaseModel, ConfigDict, Field
-from typing_extensions import NotRequired
 
 
 class InMemoryExporter(SpanExporter):
     def __init__(self):
-        self.spans: List[Dict[str, Any]] = []
+        self.spans: list[dict[str, Any]] = []
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         for span in spans:
@@ -45,7 +45,7 @@ class InMemoryExporter(SpanExporter):
     def shutdown(self):
         pass
 
-    def get_spans(self) -> List[Dict[str, Any]]:
+    def get_spans(self) -> list[dict[str, Any]]:
         return self.spans
 
     def clear(self):
@@ -125,7 +125,7 @@ class Message(TypedDict):
     role: str
     content: str
     name: NotRequired[str]
-    function_call: NotRequired[Dict[str, str]]
+    function_call: NotRequired[dict[str, str]]
 
 
 class ModelParams(TypedDict, total=False):
@@ -136,5 +136,5 @@ class ModelParams(TypedDict, total=False):
     top_p: float
     frequency_penalty: float
     presence_penalty: float
-    stop: Union[str, List[str]]
-    functions: List[Dict[str, Any]]
+    stop: str | list[str]
+    functions: list[dict[str, Any]]

synth_ai/v0/tracing/context.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 from contextlib import contextmanager
-from typing import Any, Dict, Generic, Optional, TypeVar
+from typing import Any, Generic, TypeVar
 
 from .local import (
     _local,
@@ -24,7 +24,7 @@ class ContextState(Generic[T]):
         self.thread_local_attr = thread_local_attr
         self.context_var = context_var
 
-    def get(self) -> Optional[T]:
+    def get(self) -> T | None:
         """Get value from appropriate context."""
         try:
             asyncio.get_running_loop()
@@ -32,7 +32,7 @@ class ContextState(Generic[T]):
         except RuntimeError:
             return getattr(_local, self.thread_local_attr, None)
 
-    def set(self, value: T) -> Optional[T]:
+    def set(self, value: T) -> T | None:
         """Set value in appropriate context."""
         try:
             asyncio.get_running_loop()
@@ -41,7 +41,7 @@ class ContextState(Generic[T]):
             setattr(_local, self.thread_local_attr, value)
             return None
 
-    def reset(self, token: Optional[T] = None) -> None:
+    def reset(self, token: T | None = None) -> None:
         """Reset/clear value from appropriate context."""
         try:
             asyncio.get_running_loop()
@@ -69,7 +69,7 @@ def trace_context(
     system_name: str,
     system_id: str,
     system_instance_id: str,
-    system_instance_metadata: Optional[Dict[str, Any]] = None,
+    system_instance_metadata: dict[str, Any] | None = None,
 ):
     """Context manager for setting up tracing context.
 
@@ -132,7 +132,7 @@ def trace_context(
             active_events_state.reset()
 
 
-def get_current_context() -> Dict[str, Any]:
+def get_current_context() -> dict[str, Any]:
     """Get the current tracing context.
 
     Returns:

synth_ai/v0/tracing/decorators.py

@@ -3,8 +3,9 @@ import inspect
 import logging
 import os
 import time
+from collections.abc import Callable
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Literal, ParamSpec, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Literal, ParamSpec, TypeVar, Union
 
 if TYPE_CHECKING:
     from .trackers import SynthTrackerAsync, SynthTrackerSync
@@ -207,8 +208,8 @@ def trace_event_sync(
                     # Collect traced inputs and outputs
                     traced_inputs, traced_outputs = synth_tracker_sync.get_traced_data()
 
-                    compute_steps_by_origin: Dict[
-                        Literal["agent", "environment"], Dict[str, List[Any]]
+                    compute_steps_by_origin: dict[
+                        Literal["agent", "environment"], dict[str, list[Any]]
                     ] = {
                         "agent": {"inputs": [], "outputs": []},
                         "environment": {"inputs": [], "outputs": []},
@@ -464,8 +465,8 @@ def trace_event_async(
                     # Collect traced inputs and outputs
                     traced_inputs, traced_outputs = synth_tracker_async.get_traced_data()
 
-                    compute_steps_by_origin: Dict[
-                        Literal["agent", "environment"], Dict[str, List[Any]]
+                    compute_steps_by_origin: dict[
+                        Literal["agent", "environment"], dict[str, list[Any]]
                     ] = {
                         "agent": {"inputs": [], "outputs": []},
                         "environment": {"inputs": [], "outputs": []},

synth_ai/v0/tracing/events/manage.py

@@ -130,7 +130,7 @@ def clear_current_event(event_type: str):
         logger.debug(f"Cleared current event of type {event_type}")
 
 
-def end_event(event_type: str) -> Optional[Event]:
+def end_event(event_type: str) -> Event | None:
     """End the current event and store it."""
     current_event = get_current_event(event_type)
     if current_event:

synth_ai/v0/tracing/events/store.py

@@ -2,7 +2,7 @@ import json
 import logging
 import time
 from threading import RLock  # Change this import
-from typing import Any, Dict, List
+from typing import Any
 
 from ..abstractions import Event, EventPartitionElement, SystemTrace
 from ..local import (  # Import context variables
@@ -15,7 +15,7 @@ logger = logging.getLogger(__name__)
 
 class EventStore:
     def __init__(self) -> None:
-        self._traces: Dict[str, SystemTrace] = {}
+        self._traces: dict[str, SystemTrace] = {}
         self._lock = RLock()  # Use RLock instead of Lock
         self.logger = logging.getLogger(__name__)
 
@@ -136,7 +136,7 @@ class EventStore:
         #     self.logger.error(f"Error in add_event: {str(e)}", exc_info=True)
         #     raise
 
-    def get_system_traces(self) -> List[SystemTrace]:
+    def get_system_traces(self) -> list[SystemTrace]:
         """Get all system traces."""
         with self._lock:
             self.end_all_active_events()
@@ -196,7 +196,7 @@ class EventStore:
                 default=str,
             )
 
-    def _event_to_dict(self, event: Event) -> Dict[str, Any]:
+    def _event_to_dict(self, event: Event) -> dict[str, Any]:
         """Convert an Event object to a dictionary."""
         return {
             "event_type": event.event_type,
@@ -225,3 +225,4 @@ class EventStore:
 
 # Global event store instance
 event_store = EventStore()
+# ruff: noqa

synth_ai/v0/tracing/immediate_client.py

@@ -1,7 +1,6 @@
 import asyncio
 import logging
 import time
-from typing import Dict
 
 import httpx
 
@@ -20,7 +19,7 @@ class ImmediateLogClient(BaseLogClient):
         super().__init__(config)
         self.client_manager = ClientManager.initialize(config)
 
-    def send_event(self, event: Event, system_info: Dict[str, str]) -> bool:
+    def send_event(self, event: Event, system_info: dict[str, str]) -> bool:
         """Send a single event with retries and fallback"""
         from .retry_queue import (
             retry_queue,  # Import here to avoid circular import
@@ -71,7 +70,7 @@ class AsyncImmediateLogClient(BaseAsyncLogClient):
         super().__init__(config)
         self.client_manager = ClientManager.initialize(config)
 
-    async def send_event(self, event: Event, system_info: Dict[str, str]) -> bool:
+    async def send_event(self, event: Event, system_info: dict[str, str]) -> bool:
         """Send a single event with retries and fallback (async version)"""
         from .retry_queue import retry_queue
 
@@ -96,7 +95,7 @@ class AsyncImmediateLogClient(BaseAsyncLogClient):
                         f"No access token received from auth endpoint. Response data: {auth_data}"
                     )
                     return False
-            except Exception as e:
+            except Exception:
                 # logger.error(f"Failed to get auth token: {e}")
                 return False
 
@@ -138,7 +137,7 @@ class AsyncImmediateLogClient(BaseAsyncLogClient):
                         event.id = response_data.get("event_id")
                         return True
 
-                    except Exception as e:
+                    except Exception:
                         # last_exception = e
                         # logger.error(f"Upload attempt {attempt + 1} failed: {str(e)}")
                         if attempt < self.config.max_retries:

synth_ai/v0/tracing/local.py

@@ -1,7 +1,7 @@
 import logging
 import threading
 from contextvars import ContextVar
-from typing import Any, Dict
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -12,7 +12,7 @@ _local = threading.local()
 system_name_var: ContextVar[str] = ContextVar("system_name", default=None)
 system_id_var: ContextVar[str] = ContextVar("system_id", default=None)
 system_instance_id_var: ContextVar[str] = ContextVar("system_instance_id", default=None)
-system_instance_metadata_var: ContextVar[Dict[str, Any]] = ContextVar(
+system_instance_metadata_var: ContextVar[dict[str, Any]] = ContextVar(
     "system_instance_metadata", default={}
 )
-active_events_var: ContextVar[Dict[str, Any]] = ContextVar("active_events", default={})
+active_events_var: ContextVar[dict[str, Any]] = ContextVar("active_events", default={})

synth_ai/v0/tracing/log_client_base.py

@@ -1,4 +1,3 @@
-from typing import Dict
 
 from .abstractions import Event
 from .config import TracingConfig
@@ -11,7 +10,7 @@ class BaseLogClient:
         self.config = config
         self.client_manager = None
 
-    def _prepare_payload(self, event: Event, system_info: Dict[str, str]) -> Dict:
+    def _prepare_payload(self, event: Event, system_info: dict[str, str]) -> dict:
         """Prepare the payload for sending."""
         return {
             "event": event.to_dict(),
@@ -33,7 +32,7 @@ class BaseLogClient:
         pass
 
     def _handle_failure(
-        self, event: Event, system_info: Dict[str, str], exception: Exception
+        self, event: Event, system_info: dict[str, str], exception: Exception
     ) -> None:
         """Handle failed event sending."""
         pass
@@ -46,7 +45,7 @@ class BaseAsyncLogClient:
         self.config = config
         self.client_manager = None
 
-    def _prepare_payload(self, event: Event, system_info: Dict[str, str]) -> Dict:
+    def _prepare_payload(self, event: Event, system_info: dict[str, str]) -> dict:
         """Prepare the payload for sending."""
         return {
             "event": event.to_dict(),
@@ -68,7 +67,7 @@ class BaseAsyncLogClient:
         pass
 
     def _handle_failure(
-        self, event: Event, system_info: Dict[str, str], exception: Exception
+        self, event: Event, system_info: dict[str, str], exception: Exception
     ) -> None:
         """Handle failed event sending."""
         pass

synth_ai/v0/tracing/retry_queue.py

@@ -3,7 +3,6 @@ import threading
 import time
 from collections import deque
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Tuple
 
 from .abstractions import Event
 from .config import TracingConfig
@@ -16,7 +15,7 @@ class QueuedEvent:
     """Represents an event that failed to upload and needs to be retried."""
 
     event: Event
-    system_info: Dict[str, str]
+    system_info: dict[str, str]
     attempt_count: int = 0
     last_attempt: float = 0
 
@@ -31,7 +30,7 @@ class RetryQueue:
         self._is_processing = False
         self._batch_size = config.batch_size
 
-    def add_failed_event(self, event: Event, system_info: Dict[str, str]) -> None:
+    def add_failed_event(self, event: Event, system_info: dict[str, str]) -> None:
         """Add a failed event to the retry queue."""
         with self._lock:
             # Check if event is already in queue to avoid duplicates
@@ -53,7 +52,7 @@ class RetryQueue:
             )
             logger.debug(f"Added event to retry queue. Queue size: {len(self.queue)}")
 
-    def get_retryable_events(self, max_events: Optional[int] = None) -> List[QueuedEvent]:
+    def get_retryable_events(self, max_events: int | None = None) -> list[QueuedEvent]:
         """Get events that are ready to be retried."""
         now = time.time()
         retryable = []
@@ -74,7 +73,7 @@ class RetryQueue:
 
         return retryable
 
-    def process_sync(self) -> Tuple[int, int]:
+    def process_sync(self) -> tuple[int, int]:
         """Process the retry queue synchronously.
 
         Returns:
@@ -125,7 +124,7 @@ class RetryQueue:
 
         return success_count, failure_count
 
-    async def process_async(self) -> Tuple[int, int]:
+    async def process_async(self) -> tuple[int, int]:
         """Process the retry queue asynchronously.
 
         Returns: