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

synth_ai/v0/tracing/trackers.py

@@ -1,6 +1,6 @@
 import asyncio
 import contextvars
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import Any, Literal
 
 from pydantic import BaseModel
 
@@ -29,9 +29,9 @@ class SynthTrackerSync:
     @classmethod
     def track_lm(
         cls,
-        messages: List[Dict[str, str]],
+        messages: list[dict[str, str]],
         model_name: str,
-        model_params: Optional[Dict[str, Union[str, int, float]]] = None,
+        model_params: dict[str, str | int | float] | None = None,
         finetune: bool = False,
     ):
         # print("Tracking LM call in sync context - ",messages)  # Added logging
@@ -52,9 +52,9 @@ class SynthTrackerSync:
     def track_state(
         cls,
         variable_name: str,
-        variable_value: Union[BaseModel, str, dict, int, float, bool, list, None],
+        variable_value: BaseModel | str | dict | int | float | bool | list | None,
         origin: Literal["agent", "environment"],
-        annotation: Optional[str] = None,
+        annotation: str | None = None,
     ):
         # Skip if value is not a trackable type instead of raising error
         if not isinstance(variable_value, VALID_TYPES):
@@ -79,7 +79,7 @@ class SynthTrackerSync:
             # )
 
     @classmethod
-    def get_traced_data(cls) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    def get_traced_data(cls) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
         return getattr(cls._local, "inputs", []), getattr(cls._local, "outputs", [])
 
     @classmethod
@@ -93,7 +93,7 @@ class SynthTrackerSync:
     @classmethod
     def track_lm_output(
         cls,
-        messages: List[Dict[str, str]],
+        messages: list[dict[str, str]],
         model_name: str,
         finetune: bool = False,
     ):
@@ -137,9 +137,9 @@ class SynthTrackerAsync:
     @classmethod
     def track_lm(
         cls,
-        messages: List[Dict[str, str]],
+        messages: list[dict[str, str]],
         model_name: str,
-        model_params: Optional[Dict[str, Union[str, int, float]]] = None,
+        model_params: dict[str, str | int | float] | None = None,
         finetune: bool = False,
     ):
         # print("Tracking LM call in async context")  # Added logging
@@ -165,9 +165,9 @@ class SynthTrackerAsync:
     def track_state(
         cls,
         variable_name: str,
-        variable_value: Union[BaseModel, str, dict, int, float, bool, list, None],
+        variable_value: BaseModel | str | dict | int | float | bool | list | None,
         origin: Literal["agent", "environment"],
-        annotation: Optional[str] = None,
+        annotation: str | None = None,
         io_type: Literal["input", "output"] = "output",
     ):
         # Skip if value is not a trackable type instead of raising error
@@ -207,7 +207,7 @@ class SynthTrackerAsync:
             # )
 
     @classmethod
-    def get_traced_data(cls) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    def get_traced_data(cls) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
         traced_inputs = trace_inputs_var.get()
         traced_outputs = trace_outputs_var.get()
         return traced_inputs, traced_outputs
@@ -222,7 +222,7 @@ class SynthTrackerAsync:
     @classmethod
     def track_lm_output(
         cls,
-        messages: List[Dict[str, str]],
+        messages: list[dict[str, str]],
         model_name: str,
         finetune: bool = False,
     ):
@@ -270,9 +270,9 @@ class SynthTracker:
     @classmethod
     def track_lm(
         cls,
-        messages: List[Dict[str, str]],
+        messages: list[dict[str, str]],
         model_name: str,
-        model_params: Optional[Dict[str, Union[str, int, float]]] = None,
+        model_params: dict[str, str | int | float] | None = None,
         finetune: bool = False,
     ):
         # Debug logging disabled: print("DEBUG: Tracking LM call")
@@ -334,9 +334,9 @@ class SynthTracker:
     def track_state(
         cls,
         variable_name: str,
-        variable_value: Union[BaseModel, str, dict, int, float, bool, list, None],
+        variable_value: BaseModel | str | dict | int | float | bool | list | None,
         origin: Literal["agent", "environment"],
-        annotation: Optional[str] = None,
+        annotation: str | None = None,
     ):
         """
         Track a state change or variable value within the current trace.
@@ -392,7 +392,7 @@ class SynthTracker:
         async_sync: Literal[
             "async", "sync", ""
         ] = "",  # Force only async or sync data to be returned
-    ) -> Tuple[list, list]:
+    ) -> tuple[list, list]:
         traced_inputs, traced_outputs = [], []
         # Debug logging disabled: print(
         #     f"\nDEBUG: Getting traced data with async_sync='{async_sync}'"
@@ -424,7 +424,7 @@ class SynthTracker:
     @classmethod
     def track_lm_output(
         cls,
-        messages: List[Dict[str, str]],
+        messages: list[dict[str, str]],
         model_name: str,
         finetune: bool = False,
     ):
@@ -452,10 +452,10 @@ class SynthTracker:
 
 
 def track_messages_sync(
-    input_messages: List[Message],
-    output_messages: List[Message],
+    input_messages: list[Message],
+    output_messages: list[Message],
     model_name: str,
-    model_params: Optional[ModelParams] = None,
+    model_params: ModelParams | None = None,
     finetune: bool = False,
 ) -> None:
     """Track both input and output messages in a conversation synchronously.
@@ -484,10 +484,10 @@ def track_messages_sync(
 
 
 async def track_messages_async(
-    input_messages: List[Message],
-    output_messages: List[Message],
+    input_messages: list[Message],
+    output_messages: list[Message],
     model_name: str,
-    model_params: Optional[ModelParams] = None,
+    model_params: ModelParams | None = None,
     finetune: bool = False,
 ) -> None:
     """Track both input and output messages in a conversation asynchronously.

synth_ai/v0/tracing/upload.py

@@ -1,3 +1,4 @@
+# ruff: noqa
 import asyncio
 import json
 import logging
@@ -370,6 +371,10 @@ def upload_helper(
         raise ValueError("SYNTH_API_KEY environment variable not set")
     base_url = os.getenv("SYNTH_ENDPOINT_OVERRIDE", "https://agent-learning.onrender.com")
 
+"""Legacy block below retained for reference and disabled for linting/parsing.
+Start disabled block.
+"""
+"""
 from .decorators import _local, active_events_var
 from .trackers import synth_tracker_async, synth_tracker_sync
 
@@ -502,3 +507,4 @@ from .trackers import synth_tracker_async, synth_tracker_sync
             print("\nDataset:")
             print(json.dumps(dataset_dict, indent=2))
         raise
+"""

synth_ai/v0/tracing_v1/__init__.py

@@ -10,7 +10,7 @@ warnings.warn(
 )
 
 # Re-export the main components with deprecation warnings
+from .abstractions import *
 from .config import *
 from .decorators import *
 from .trackers import *
-from .abstractions import *

synth_ai/v0/tracing_v1/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_v1/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_v1/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_v1/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_v1/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_v1/decorators.py

@@ -1,11 +1,12 @@
 # synth_sdk/tracing/decorators.py
 import inspect
 import logging
-import warnings
 import os
 import time
+import warnings
+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
@@ -218,8 +219,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": []},
@@ -485,8 +486,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_v1/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_v1/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_v1/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: