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

synth_ai/lm/overrides.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
-from contextlib import contextmanager
-from typing import Any, Dict, List, Optional, Tuple
 import contextvars
+from contextlib import contextmanager
+from typing import Any
 
 from synth_ai.lm.injection import (
-    set_injection_rules,
-    clear_injection_rules,
     apply_injection as _apply_injection,
 )
+from synth_ai.lm.injection import (
+    clear_injection_rules,
+    set_injection_rules,
+)
 
 # Context to hold a list of override specs to evaluate per-call
 # Each spec shape (minimal v1):
@@ -18,29 +20,29 @@ from synth_ai.lm.injection import (
 #   "params": { ... api params to override ... },
 #   "tools": { ... optional tools overrides ... },
 # }
-_override_specs_ctx: contextvars.ContextVar[Optional[List[Dict[str, Any]]]] = contextvars.ContextVar(
-    "override_specs", default=None
+_override_specs_ctx: contextvars.ContextVar[list[dict[str, Any]] | None] = (
+    contextvars.ContextVar("override_specs", default=None)
 )
 
 # ContextVars actually applied for the specific call once matched
-_param_overrides_ctx: contextvars.ContextVar[Optional[Dict[str, Any]]] = contextvars.ContextVar(
+_param_overrides_ctx: contextvars.ContextVar[dict[str, Any] | None] = contextvars.ContextVar(
     "param_overrides", default=None
 )
-_tool_overrides_ctx: contextvars.ContextVar[Optional[Dict[str, Any]]] = contextvars.ContextVar(
+_tool_overrides_ctx: contextvars.ContextVar[dict[str, Any] | None] = contextvars.ContextVar(
     "tool_overrides", default=None
 )
-_current_override_label_ctx: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+_current_override_label_ctx: contextvars.ContextVar[str | None] = contextvars.ContextVar(
     "override_label", default=None
 )
 
 
-def set_override_specs(specs: List[Dict[str, Any]]):
+def set_override_specs(specs: list[dict[str, Any]]):
     if not isinstance(specs, list):
         raise ValueError("override specs must be a list of dicts")
     return _override_specs_ctx.set(specs)
 
 
-def get_override_specs() -> Optional[List[Dict[str, Any]]]:
+def get_override_specs() -> list[dict[str, Any]] | None:
     return _override_specs_ctx.get()
 
 
@@ -48,7 +50,7 @@ def clear_override_specs(token) -> None:
     _override_specs_ctx.reset(token)
 
 
-def _matches(spec: Dict[str, Any], messages: List[Dict[str, Any]]) -> bool:
+def _matches(spec: dict[str, Any], messages: list[dict[str, Any]]) -> bool:
     match = spec.get("match") or {}
     contains = match.get("contains")
     role = match.get("role")  # optional
@@ -69,7 +71,7 @@ def _matches(spec: Dict[str, Any], messages: List[Dict[str, Any]]) -> bool:
     return False
 
 
-def resolve_override_for_messages(messages: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+def resolve_override_for_messages(messages: list[dict[str, Any]]) -> dict[str, Any] | None:
     specs = get_override_specs() or []
     for spec in specs:
         try:
@@ -81,12 +83,12 @@ def resolve_override_for_messages(messages: List[Dict[str, Any]]) -> Optional[Di
     return None
 
 
-def apply_injection(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def apply_injection(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
     # Delegate to injection.apply_injection
     return _apply_injection(messages)
 
 
-def apply_param_overrides(api_params: Dict[str, Any]) -> Dict[str, Any]:
+def apply_param_overrides(api_params: dict[str, Any]) -> dict[str, Any]:
     ov = _param_overrides_ctx.get()
     if not ov:
         return api_params
@@ -96,7 +98,7 @@ def apply_param_overrides(api_params: Dict[str, Any]) -> Dict[str, Any]:
     return api_params
 
 
-def apply_tool_overrides(api_params: Dict[str, Any]) -> Dict[str, Any]:
+def apply_tool_overrides(api_params: dict[str, Any]) -> dict[str, Any]:
     """Apply tool overrides to OpenAI/Anthropic-like api_params in place.
 
     Supports keys under spec["tools"]:
@@ -138,7 +140,7 @@ def apply_tool_overrides(api_params: Dict[str, Any]) -> Dict[str, Any]:
 
 
 @contextmanager
-def use_overrides_for_messages(messages: List[Dict[str, Any]]):
+def use_overrides_for_messages(messages: list[dict[str, Any]]):
     """Resolve an override spec against messages and apply its contexts within the scope.
 
     - Sets injection rules and param overrides if present on the matched spec.
@@ -174,7 +176,7 @@ def use_overrides_for_messages(messages: List[Dict[str, Any]]):
             _current_override_label_ctx.reset(label_tok)
 
 
-def get_current_override_label() -> Optional[str]:
+def get_current_override_label() -> str | None:
     return _current_override_label_ctx.get()
 
 
@@ -189,7 +191,7 @@ class LMOverridesContext:
             run_pipeline()
     """
 
-    def __init__(self, override_specs: Optional[List[Dict[str, Any]]] | Dict[str, Any] = None):
+    def __init__(self, override_specs: list[dict[str, Any]] | None | dict[str, Any] = None):
         if isinstance(override_specs, dict):
             override_specs = [override_specs]
         self._specs = override_specs or []

synth_ai/lm/provider_support/__init__.py

@@ -2,7 +2,7 @@
 Provider support for LLM services with integrated tracing.
 """
 
-from .openai import OpenAI, AsyncOpenAI
 from .anthropic import Anthropic, AsyncAnthropic
+from .openai import AsyncOpenAI, OpenAI
 
 __all__ = ["OpenAI", "AsyncOpenAI", "Anthropic", "AsyncAnthropic"]

synth_ai/lm/provider_support/anthropic.py

@@ -6,14 +6,13 @@ Analogous to the modified OpenAI version.
 import logging
 import types
 from dataclasses import dataclass
-from typing import Optional
 
 try:
     import anthropic
-except ImportError:
+except ImportError as err:
     raise ModuleNotFoundError(
         "Please install anthropic to use this feature: 'pip install anthropic'"
-    )
+    ) from err
 
 try:
     from anthropic import AsyncClient, Client
@@ -27,14 +26,15 @@ from langfuse.decorators import langfuse_context
 from langfuse.utils import _get_timestamp
 from langfuse.utils.langfuse_singleton import LangfuseSingleton
 from wrapt import wrap_function_wrapper
+
 from synth_ai.lm.overrides import (
-    use_overrides_for_messages,
     apply_injection as apply_injection_overrides,
+)
+from synth_ai.lm.overrides import (
     apply_param_overrides,
     apply_tool_overrides,
+    use_overrides_for_messages,
 )
-from synth_ai.lm.injection import apply_injection
-
 from synth_ai.lm.provider_support.suppress_logging import *
 from synth_ai.tracing_v1.trackers import (
     synth_tracker_async,
@@ -799,7 +799,7 @@ class LangfuseAnthropicResponseGeneratorAsync:
 
 
 class AnthropicLangfuse:
-    _langfuse: Optional[Langfuse] = None
+    _langfuse: Langfuse | None = None
 
     def initialize(self):
         self._langfuse = LangfuseSingleton().get(
@@ -946,14 +946,14 @@ class AnthropicLangfuse:
 
         anthropic.AsyncClient.__init__ = new_async_init
 
-        setattr(anthropic, "langfuse_public_key", None)
-        setattr(anthropic, "langfuse_secret_key", None)
-        setattr(anthropic, "langfuse_host", None)
-        setattr(anthropic, "langfuse_debug", None)
-        setattr(anthropic, "langfuse_enabled", True)
-        setattr(anthropic, "langfuse_sample_rate", None)
-        setattr(anthropic, "langfuse_auth_check", self.langfuse_auth_check)
-        setattr(anthropic, "flush_langfuse", self.flush)
+        anthropic.langfuse_public_key = None
+        anthropic.langfuse_secret_key = None
+        anthropic.langfuse_host = None
+        anthropic.langfuse_debug = None
+        anthropic.langfuse_enabled = True
+        anthropic.langfuse_sample_rate = None
+        anthropic.langfuse_auth_check = self.langfuse_auth_check
+        anthropic.flush_langfuse = self.flush
 
 
 modifier = AnthropicLangfuse()

synth_ai/lm/provider_support/openai.py

@@ -4,7 +4,6 @@ import types
 from collections import defaultdict
 from dataclasses import dataclass
 from inspect import isclass
-from typing import List, Optional
 
 import openai.resources
 from langfuse import Langfuse
@@ -15,22 +14,25 @@ from langfuse.utils.langfuse_singleton import LangfuseSingleton
 from packaging.version import Version
 from pydantic import BaseModel
 from wrapt import wrap_function_wrapper
+
 from synth_ai.lm.overrides import (
-    use_overrides_for_messages,
     apply_injection as apply_injection_overrides,
+)
+from synth_ai.lm.overrides import (
     apply_param_overrides,
     apply_tool_overrides,
+    use_overrides_for_messages,
 )
-from synth_ai.lm.injection import apply_injection
-
 from synth_ai.lm.provider_support.suppress_logging import *
 from synth_ai.tracing_v1.abstractions import MessageInputs
 from synth_ai.tracing_v1.trackers import synth_tracker_async, synth_tracker_sync
 
 try:
     import openai
-except ImportError:
-    raise ModuleNotFoundError("Please install OpenAI to use this feature: 'pip install openai'")
+except ImportError as err:
+    raise ModuleNotFoundError(
+        "Please install OpenAI to use this feature: 'pip install openai'"
+    ) from err
 
 # CREDIT TO LANGFUSE FOR OPEN-SOURCING THE CODE THAT THIS IS BASED ON
 # USING WITH MIT LICENSE PERMISSION
@@ -59,7 +61,7 @@ class OpenAiDefinition:
     method: str
     type: str
     sync: bool
-    min_version: Optional[str] = None
+    min_version: str | None = None
 
 
 OPENAI_METHODS_V0 = [
@@ -212,7 +214,7 @@ def _extract_chat_response(kwargs: dict):
     Extracts the LLM output from the response.
     """
     response = {
-        "role": kwargs.get("role", None),
+        "role": kwargs.get("role"),
     }
 
     if kwargs.get("function_call") is not None:
@@ -221,7 +223,7 @@ def _extract_chat_response(kwargs: dict):
     if kwargs.get("tool_calls") is not None:
         response.update({"tool_calls": kwargs["tool_calls"]})
 
-    response["content"] = kwargs.get("content", None)
+    response["content"] = kwargs.get("content")
     return response
 
 
@@ -418,7 +420,7 @@ def _extract_streamed_openai_response(resource, chunks):
             usage = chunk_usage
 
         # Process choices
-        choices = chunk.get("choices", [])
+        choices = chunk.get("choices", [])  # noqa: F841
         # logger.debug(f"Extracted - model: {model}, choices: {choices}")
 
     # logger.debug(f"Final completion: {completion}")
@@ -762,7 +764,7 @@ async def _wrap_async(open_ai_resource: OpenAiDefinition, initialize, wrapped, a
 
 
 class OpenAILangfuse:
-    _langfuse: Optional[Langfuse] = None
+    _langfuse: Langfuse | None = None
 
     def initialize(self):
         self._langfuse = LangfuseSingleton().get(
@@ -820,15 +822,15 @@ class OpenAILangfuse:
                 else _wrap_async(resource, self.initialize),
             )
 
-        setattr(openai, "langfuse_public_key", None)
-        setattr(openai, "langfuse_secret_key", None)
-        setattr(openai, "langfuse_host", None)
-        setattr(openai, "langfuse_debug", None)
-        setattr(openai, "langfuse_enabled", True)
-        setattr(openai, "langfuse_sample_rate", None)
-        setattr(openai, "langfuse_mask", None)
-        setattr(openai, "langfuse_auth_check", self.langfuse_auth_check)
-        setattr(openai, "flush_langfuse", self.flush)
+        openai.langfuse_public_key = None
+        openai.langfuse_secret_key = None
+        openai.langfuse_host = None
+        openai.langfuse_debug = None
+        openai.langfuse_enabled = True
+        openai.langfuse_sample_rate = None
+        openai.langfuse_mask = None
+        openai.langfuse_auth_check = self.langfuse_auth_check
+        openai.flush_langfuse = self.flush
 
 
 modifier = OpenAILangfuse()
@@ -843,7 +845,7 @@ def auth_check():
     return modifier._langfuse.auth_check()
 
 
-def _filter_image_data(messages: List[dict]):
+def _filter_image_data(messages: list[dict]):
     """https://platform.openai.com/docs/guides/vision?lang=python
 
     The messages array remains the same, but the 'image_url' is removed from the 'content' array.

synth_ai/lm/structured_outputs/handler.py

@@ -8,10 +8,12 @@ in the requested structured format (Pydantic models).
 import logging
 import time
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
+from collections.abc import Callable
+from typing import Any, Literal
 
 from pydantic import BaseModel
 
+from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
 from synth_ai.lm.core.exceptions import StructuredOutputCoercionFailureException
 from synth_ai.lm.structured_outputs.inject import (
     inject_structured_output_instructions,
@@ -22,7 +24,6 @@ from synth_ai.lm.structured_outputs.rehabilitate import (
     pull_out_structured_output,
 )
 from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
 
 logger = logging.getLogger(__name__)
 
@@ -30,26 +31,27 @@ logger = logging.getLogger(__name__)
 class StructuredHandlerBase(ABC):
     """
     Abstract base class for structured output handlers.
-    
+
     Handles the logic for ensuring language models return properly formatted
     structured outputs, with retry logic and error handling.
-    
+
     Attributes:
         core_client: Primary vendor client for API calls
         retry_client: Client used for retry attempts (may use different model)
         handler_params: Configuration parameters including retry count
         structured_output_mode: Either "stringified_json" or "forced_json"
     """
+
     core_client: VendorBase
     retry_client: VendorBase
-    handler_params: Dict[str, Any]
+    handler_params: dict[str, Any]
     structured_output_mode: Literal["stringified_json", "forced_json"]
 
     def __init__(
         self,
         core_client: VendorBase,
         retry_client: VendorBase,
-        handler_params: Optional[Dict[str, Any]] = None,
+        handler_params: dict[str, Any] | None = None,
         structured_output_mode: Literal["stringified_json", "forced_json"] = "stringified_json",
     ):
         self.core_client = core_client
@@ -59,7 +61,7 @@ class StructuredHandlerBase(ABC):
 
     async def call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         temperature: float = 0.0,
@@ -74,7 +76,7 @@ class StructuredHandlerBase(ABC):
             model=model,
             response_model=response_model,
             api_call_method=self.core_client._hit_api_async_structured_output
-            if (not not response_model and self.structured_output_mode == "forced_json")
+            if (response_model and self.structured_output_mode == "forced_json")
             else self.core_client._hit_api_async,
             temperature=temperature,
             use_ephemeral_cache_only=use_ephemeral_cache_only,
@@ -83,7 +85,7 @@ class StructuredHandlerBase(ABC):
 
     def call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         response_model: BaseModel,
         model: str,
         temperature: float = 0.0,
@@ -97,7 +99,7 @@ class StructuredHandlerBase(ABC):
             model=model,
             response_model=response_model,
             api_call_method=self.core_client._hit_api_sync_structured_output
-            if (not not response_model and self.structured_output_mode == "forced_json")
+            if (response_model and self.structured_output_mode == "forced_json")
             else self.core_client._hit_api_sync,
             temperature=temperature,
             use_ephemeral_cache_only=use_ephemeral_cache_only,
@@ -107,7 +109,7 @@ class StructuredHandlerBase(ABC):
     @abstractmethod
     async def _process_call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         api_call_method,
@@ -119,7 +121,7 @@ class StructuredHandlerBase(ABC):
     @abstractmethod
     def _process_call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         api_call_method,
@@ -132,24 +134,24 @@ class StructuredHandlerBase(ABC):
 class StringifiedJSONHandler(StructuredHandlerBase):
     core_client: VendorBase
     retry_client: VendorBase
-    handler_params: Dict[str, Any]
+    handler_params: dict[str, Any]
 
     def __init__(
         self,
         core_client: VendorBase,
         retry_client: VendorBase,
-        handler_params: Dict[str, Any] = {"retries": 3},
+        handler_params: dict[str, Any] | None = None,
     ):
         super().__init__(
             core_client,
             retry_client,
-            handler_params,
+            handler_params or {"retries": 3},
             structured_output_mode="stringified_json",
         )
 
     async def _process_call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         temperature: float,
@@ -170,7 +172,7 @@ class StringifiedJSONHandler(StructuredHandlerBase):
                 response_model=response_model,
                 previously_failed_error_messages=previously_failed_error_messages,
             )
-            t0 = time.time()
+            # t0 = time.time()  # unused
             raw_text_response_or_cached_hit = await api_call_method(
                 messages=messages_with_json_formatting_instructions,
                 model=model,
@@ -184,7 +186,7 @@ class StringifiedJSONHandler(StructuredHandlerBase):
             assert type(raw_text_response_or_cached_hit) in [str, BaseLMResponse], (
                 f"Expected str or BaseLMResponse, got {type(raw_text_response_or_cached_hit)}"
             )
-            if type(raw_text_response_or_cached_hit) == BaseLMResponse:
+            if isinstance(raw_text_response_or_cached_hit, BaseLMResponse):
                 # print("Got cached hit, returning directly")
                 raw_text_response = raw_text_response_or_cached_hit.raw_response
             else:
@@ -242,7 +244,7 @@ class StringifiedJSONHandler(StructuredHandlerBase):
 
     def _process_call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         temperature: float,
@@ -277,7 +279,7 @@ class StringifiedJSONHandler(StructuredHandlerBase):
             assert type(raw_text_response_or_cached_hit) in [str, BaseLMResponse], (
                 f"Expected str or BaseLMResponse, got {type(raw_text_response_or_cached_hit)}"
             )
-            if type(raw_text_response_or_cached_hit) == BaseLMResponse:
+            if isinstance(raw_text_response_or_cached_hit, BaseLMResponse):
                 logger.info("Got cached hit, returning directly")
                 raw_text_response = raw_text_response_or_cached_hit.raw_response
             else:
@@ -320,26 +322,26 @@ class StringifiedJSONHandler(StructuredHandlerBase):
 class ForcedJSONHandler(StructuredHandlerBase):
     core_client: VendorBase
     retry_client: VendorBase
-    handler_params: Dict[str, Any]
+    handler_params: dict[str, Any]
 
     def __init__(
         self,
         core_client: VendorBase,
         retry_client: VendorBase,
-        handler_params: Dict[str, Any] = {},
+        handler_params: dict[str, Any] | None = None,
         reasoning_effort: str = "high",
     ):
         super().__init__(
             core_client,
             retry_client,
-            handler_params,
+            handler_params or {"retries": 3},
             structured_output_mode="forced_json",
         )
         self.reasoning_effort = reasoning_effort
 
     async def _process_call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         api_call_method: Callable,
@@ -360,7 +362,7 @@ class ForcedJSONHandler(StructuredHandlerBase):
 
     def _process_call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         api_call_method: Callable,
@@ -380,16 +382,16 @@ class ForcedJSONHandler(StructuredHandlerBase):
 
 
 class StructuredOutputHandler:
-    handler: Union[StringifiedJSONHandler, ForcedJSONHandler]
+    handler: StringifiedJSONHandler | ForcedJSONHandler
     mode: Literal["stringified_json", "forced_json"]
-    handler_params: Dict[str, Any]
+    handler_params: dict[str, Any]
 
     def __init__(
         self,
         core_client: VendorBase,
         retry_client: VendorBase,
         mode: Literal["stringified_json", "forced_json"],
-        handler_params: Dict[str, Any] = {},
+        handler_params: dict[str, Any] = {},
     ):
         self.mode = mode
         if self.mode == "stringified_json":
@@ -402,11 +404,11 @@ class StructuredOutputHandler:
 
     async def call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         use_ephemeral_cache_only: bool = False,
-        lm_config: Dict[str, Any] = {},
+        lm_config: dict[str, Any] = {},
         reasoning_effort: str = "high",
     ) -> BaseLMResponse:
         # print("Output handler call async")
@@ -421,11 +423,11 @@ class StructuredOutputHandler:
 
     def call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         use_ephemeral_cache_only: bool = False,
-        lm_config: Dict[str, Any] = {},
+        lm_config: dict[str, Any] = {},
         reasoning_effort: str = "high",
     ) -> BaseLMResponse:
         return self.handler.call_sync(