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

synth_ai/lm/vendors/core/gemini_api.py

@@ -2,22 +2,21 @@ import json
 import logging
 import os
 import warnings
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any
 
 import google.genai as genai
 from google.api_core.exceptions import ResourceExhausted
 from google.genai import types
+
 from synth_ai.lm.caching.initialize import get_cache_handler
-from synth_ai.lm.tools.base import BaseTool
-from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
 from synth_ai.lm.constants import (
-    SPECIAL_BASE_TEMPS,
     GEMINI_REASONING_MODELS,
     GEMINI_THINKING_BUDGETS,
+    SPECIAL_BASE_TEMPS,
 )
+from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
 from synth_ai.lm.vendors.retries import BACKOFF_TOLERANCE, MAX_BACKOFF, backoff
-import logging
-
 
 ALIASES = {
     "gemini-2.5-flash": "gemini-2.5-flash-preview-04-17",
@@ -25,7 +24,7 @@ ALIASES = {
 
 logger = logging.getLogger(__name__)
 _CLIENT = None  # Initialize lazily when needed
-GEMINI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (ResourceExhausted,)
+GEMINI_EXCEPTIONS_TO_RETRY: tuple[type[Exception], ...] = (ResourceExhausted,)
 logging.getLogger("google.genai").setLevel(logging.ERROR)
 os.environ["GRPC_VERBOSITY"] = "ERROR"
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
@@ -49,11 +48,11 @@ def _get_client():
 
 class GeminiAPI(VendorBase):
     used_for_structured_outputs: bool = True
-    exceptions_to_retry: Tuple[Type[Exception], ...] = GEMINI_EXCEPTIONS_TO_RETRY
+    exceptions_to_retry: tuple[type[Exception], ...] = GEMINI_EXCEPTIONS_TO_RETRY
 
     def __init__(
         self,
-        exceptions_to_retry: Tuple[Type[Exception], ...] = GEMINI_EXCEPTIONS_TO_RETRY,
+        exceptions_to_retry: tuple[type[Exception], ...] = GEMINI_EXCEPTIONS_TO_RETRY,
         used_for_structured_outputs: bool = False,
     ):
         self.used_for_structured_outputs = used_for_structured_outputs
@@ -65,7 +64,7 @@ class GeminiAPI(VendorBase):
         return model_name
 
     @staticmethod
-    def _msg_to_contents(messages: List[Dict[str, Any]]) -> List[types.Content]:
+    def _msg_to_contents(messages: list[dict[str, Any]]) -> list[types.Content]:
         # contents, sys_instr = [], None
         contents = []
         for m in messages:
@@ -82,16 +81,12 @@ class GeminiAPI(VendorBase):
         return contents
 
     @staticmethod
-    def _tools_to_genai(tools: List[BaseTool]) -> List[types.Tool]:
+    def _tools_to_genai(tools: list[BaseTool]) -> list[types.Tool]:
         """Convert internal BaseTool → genai Tool."""
-        out: List[types.Tool] = []
+        out: list[types.Tool] = []
         for t in tools:
             # Assume t.to_gemini_tool() now correctly returns a FunctionDeclaration
-            # func_decl = t.to_gemini_tool()
-            if isinstance(t, dict):
-                func_decl = t
-            else:
-                func_decl = t.to_gemini_tool()
+            func_decl = t if isinstance(t, dict) else t.to_gemini_tool()
             if not isinstance(func_decl, types.FunctionDeclaration):
                 # Or fetch schema parts if to_gemini_tool still returns dict
                 # This depends on BaseTool.to_gemini_tool implementation
@@ -106,15 +101,15 @@ class GeminiAPI(VendorBase):
 
     async def _gen_content_async(
         self,
-        messages: List[Dict],
+        messages: list[dict],
         temperature: float,
         model_name: str,
         reasoning_effort: str,
-        tools: Optional[List[BaseTool]],
-        lm_config: Optional[Dict[str, Any]],
-    ) -> Tuple[str, Optional[List[Dict]]]:
+        tools: list[BaseTool] | None,
+        lm_config: dict[str, Any] | None,
+    ) -> tuple[str, list[dict] | None]:
         model_name = self.get_aliased_model_name(model_name)
-        cfg_kwargs: Dict[str, Any] = {"temperature": temperature}
+        cfg_kwargs: dict[str, Any] = {"temperature": temperature}
         if model_name in GEMINI_REASONING_MODELS and reasoning_effort in GEMINI_THINKING_BUDGETS:
             cfg_kwargs["thinking_config"] = types.ThinkingConfig(
                 thinking_budget=GEMINI_THINKING_BUDGETS[reasoning_effort]
@@ -141,15 +136,15 @@ class GeminiAPI(VendorBase):
 
     def _gen_content_sync(
         self,
-        messages: List[Dict],
+        messages: list[dict],
         temperature: float,
         model_name: str,
         reasoning_effort: str,
-        tools: Optional[List[BaseTool]],
-        lm_config: Optional[Dict[str, Any]],
-    ) -> Tuple[str, Optional[List[Dict]]]:
+        tools: list[BaseTool] | None,
+        lm_config: dict[str, Any] | None,
+    ) -> tuple[str, list[dict] | None]:
         model_name = self.get_aliased_model_name(model_name)
-        cfg_kwargs: Dict[str, Any] = {"temperature": temperature}
+        cfg_kwargs: dict[str, Any] = {"temperature": temperature}
         if model_name in GEMINI_REASONING_MODELS and reasoning_effort in GEMINI_THINKING_BUDGETS:
             cfg_kwargs["thinking_config"] = types.ThinkingConfig(
                 thinking_budget=GEMINI_THINKING_BUDGETS[reasoning_effort]
@@ -174,7 +169,7 @@ class GeminiAPI(VendorBase):
         return self._extract(resp)
 
     @staticmethod
-    def _extract(response) -> Tuple[str, Optional[List[Dict]]]:
+    def _extract(response) -> tuple[str, list[dict] | None]:
         # Extract text, handling cases where it might be missing
         try:
             text = response.text
@@ -208,13 +203,13 @@ class GeminiAPI(VendorBase):
     async def _hit_api_async(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
-        assert lm_config.get("response_model", None) is None, (
+        assert lm_config.get("response_model") is None, (
             "response_model is not supported for standard calls"
         )
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
@@ -257,13 +252,13 @@ class GeminiAPI(VendorBase):
     def _hit_api_sync(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
-        assert lm_config.get("response_model", None) is None, (
+        assert lm_config.get("response_model") is None, (
             "response_model is not supported for standard calls"
         )
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only=use_ephemeral_cache_only)

synth_ai/lm/vendors/core/mistral_api.py

@@ -1,30 +1,30 @@
 import json
 import os
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any
 
 import pydantic
 from mistralai import Mistral  # use Mistral as both sync and async client
 from pydantic import BaseModel
 
 from synth_ai.lm.caching.initialize import get_cache_handler
+from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
 from synth_ai.lm.tools.base import BaseTool
 from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
 from synth_ai.lm.vendors.core.openai_api import OpenAIStructuredOutputClient
 
 # Since the mistralai package doesn't expose an exceptions module,
 # we fallback to catching all Exceptions for retry.
-MISTRAL_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (Exception,)
+MISTRAL_EXCEPTIONS_TO_RETRY: tuple[type[Exception], ...] = (Exception,)
 
 
 class MistralAPI(VendorBase):
     used_for_structured_outputs: bool = True
-    exceptions_to_retry: Tuple = MISTRAL_EXCEPTIONS_TO_RETRY
+    exceptions_to_retry: tuple = MISTRAL_EXCEPTIONS_TO_RETRY
     _openai_fallback: Any
 
     def __init__(
         self,
-        exceptions_to_retry: Tuple[Type[Exception], ...] = MISTRAL_EXCEPTIONS_TO_RETRY,
+        exceptions_to_retry: tuple[type[Exception], ...] = MISTRAL_EXCEPTIONS_TO_RETRY,
         used_for_structured_outputs: bool = False,
     ):
         self.used_for_structured_outputs = used_for_structured_outputs
@@ -40,14 +40,14 @@ class MistralAPI(VendorBase):
     async def _hit_api_async(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        response_model: Optional[BaseModel] = None,
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
+        response_model: BaseModel | None = None,
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
-        assert lm_config.get("response_model", None) is None, (
+        assert lm_config.get("response_model") is None, (
             "response_model is not supported for standard calls"
         )
         assert not (response_model and tools), "Cannot provide both response_model and tools"
@@ -63,7 +63,7 @@ class MistralAPI(VendorBase):
             ], f"Expected BaseLMResponse or str, got {type(cache_result)}"
             return (
                 cache_result
-                if type(cache_result) == BaseLMResponse
+                if isinstance(cache_result, BaseLMResponse)
                 else BaseLMResponse(
                     raw_response=cache_result, structured_output=None, tool_calls=None
                 )
@@ -130,14 +130,14 @@ class MistralAPI(VendorBase):
     def _hit_api_sync(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        response_model: Optional[BaseModel] = None,
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
+        response_model: BaseModel | None = None,
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
-        assert lm_config.get("response_model", None) is None, (
+        assert lm_config.get("response_model") is None, (
             "response_model is not supported for standard calls"
         )
         assert not (response_model and tools), "Cannot provide both response_model and tools"
@@ -154,7 +154,7 @@ class MistralAPI(VendorBase):
             ], f"Expected BaseLMResponse or str, got {type(cache_result)}"
             return (
                 cache_result
-                if type(cache_result) == BaseLMResponse
+                if isinstance(cache_result, BaseLMResponse)
                 else BaseLMResponse(
                     raw_response=cache_result, structured_output=None, tool_calls=None
                 )
@@ -217,7 +217,7 @@ class MistralAPI(VendorBase):
     async def _hit_api_async_structured_output(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         response_model: BaseModel,
         temperature: float,
         use_ephemeral_cache_only: bool = False,
@@ -256,7 +256,7 @@ class MistralAPI(VendorBase):
     def _hit_api_sync_structured_output(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         response_model: BaseModel,
         temperature: float,
         use_ephemeral_cache_only: bool = False,

synth_ai/lm/vendors/core/openai_api.py

@@ -6,7 +6,7 @@ supporting both standard and structured output modes.
 """
 
 import json
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any
 
 import openai
 import pydantic_core
@@ -15,13 +15,13 @@ import pydantic_core
 from pydantic import BaseModel
 
 from synth_ai.lm.caching.initialize import get_cache_handler
+from synth_ai.lm.constants import OPENAI_REASONING_MODELS, SPECIAL_BASE_TEMPS
 from synth_ai.lm.tools.base import BaseTool
 from synth_ai.lm.vendors.base import BaseLMResponse
-from synth_ai.lm.constants import SPECIAL_BASE_TEMPS, OPENAI_REASONING_MODELS
 from synth_ai.lm.vendors.openai_standard import OpenAIStandard
 
 # Exceptions that should trigger retry logic for OpenAI API calls
-OPENAI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (
+OPENAI_EXCEPTIONS_TO_RETRY: tuple[type[Exception], ...] = (
     pydantic_core._pydantic_core.ValidationError,
     openai.OpenAIError,
     openai.APIConnectionError,
@@ -36,10 +36,11 @@ OPENAI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (
 class OpenAIStructuredOutputClient(OpenAIStandard):
     """
     OpenAI client with support for structured outputs.
-    
+
     This client extends the standard OpenAI client to support structured outputs
     using OpenAI's native structured output feature or response format parameter.
     """
+
     def __init__(self, synth_logging: bool = True):
         if synth_logging:
             # print("Using synth logging - OpenAIStructuredOutputClient")
@@ -58,11 +59,11 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
     async def _hit_api_async_structured_output(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         response_model: BaseModel,
         temperature: float,
         use_ephemeral_cache_only: bool = False,
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
         reasoning_effort: str = "high",
     ) -> str:
         if tools:
@@ -81,7 +82,7 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
                 dict,
                 BaseLMResponse,
             ], f"Expected dict or BaseLMResponse, got {type(cache_result)}"
-            return cache_result["response"] if type(cache_result) == dict else cache_result
+            return cache_result["response"] if isinstance(cache_result, dict) else cache_result
         if model in OPENAI_REASONING_MODELS:
             output = await self.async_client.beta.chat.completions.parse(
                 model=model,
@@ -109,11 +110,11 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
     def _hit_api_sync_structured_output(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         response_model: BaseModel,
         temperature: float,
         use_ephemeral_cache_only: bool = False,
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
         reasoning_effort: str = "high",
     ) -> str:
         if tools:
@@ -130,7 +131,7 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
                 dict,
                 BaseLMResponse,
             ], f"Expected dict or BaseLMResponse, got {type(cache_result)}"
-            return cache_result["response"] if type(cache_result) == dict else cache_result
+            return cache_result["response"] if isinstance(cache_result, dict) else cache_result
         if model in OPENAI_REASONING_MODELS:
             output = self.sync_client.beta.chat.completions.parse(
                 model=model,