synth-ai 0.1.0.dev38__py3-none-any.whl → 0.1.0.dev49__py3-none-any.whl

synth_ai/zyk/lms/vendors/core/gemini_api.py

@@ -1,306 +0,0 @@
-import json
-import logging
-import os
-import warnings
-from typing import Any, Dict, List, Optional, Tuple, Type
-
-import google.generativeai as genai
-from google.api_core.exceptions import ResourceExhausted
-from google.generativeai.types import HarmBlockThreshold, HarmCategory, Tool
-
-from synth_ai.zyk.lms.caching.initialize import (
-    get_cache_handler,
-)
-from synth_ai.zyk.lms.tools.base import BaseTool
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.zyk.lms.vendors.constants import SPECIAL_BASE_TEMPS
-from synth_ai.zyk.lms.vendors.retries import BACKOFF_TOLERANCE, backoff
-
-GEMINI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (ResourceExhausted,)
-logging.getLogger("google.generativeai").setLevel(logging.ERROR)
-os.environ["GRPC_VERBOSITY"] = "ERROR"
-# Suppress TensorFlow logging
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
-warnings.filterwarnings("ignore")
-
-SAFETY_SETTINGS = {
-    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
-    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
-    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
-    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
-}
-
-
-class GeminiAPI(VendorBase):
-    used_for_structured_outputs: bool = True
-    exceptions_to_retry: Tuple[Type[Exception], ...] = GEMINI_EXCEPTIONS_TO_RETRY
-
-    def __init__(
-        self,
-        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
-        self.exceptions_to_retry = exceptions_to_retry
-
-    def _convert_messages_to_contents(
-        self, messages: List[Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
-        contents = []
-        system_instruction = None
-        for message in messages:
-            if message["role"] == "system":
-                system_instruction = (
-                    f"<instructions>\n{message['content']}\n</instructions>"
-                )
-                continue
-            elif system_instruction:
-                text = system_instruction + "\n" + message["content"]
-            else:
-                text = message["content"]
-            contents.append(
-                {
-                    "role": message["role"],
-                    "parts": [{"text": text}],
-                }
-            )
-        return contents
-
-    def _convert_tools_to_gemini_format(self, tools: List[Any]) -> Tool:
-        function_declarations = []
-        for tool in tools:
-            # Try to use to_gemini_tool method if available, otherwise assume it's a dict
-            try:
-                function_declarations.append(tool.to_gemini_tool())
-            except AttributeError:
-                # If tool is a properly formatted dict, use it directly
-                if "name" in tool and "parameters" in tool:
-                    function_declarations.append(tool)
-                else:
-                    raise ValueError(
-                        f"Unsupported tool format. Tools must be BaseTool instances or properly formatted dictionaries."
-                    )
-        return Tool(function_declarations=function_declarations)
-
-    def _convert_args_to_dict(self, args):
-        """
-        Recursively convert Gemini's args objects to Python dictionaries.
-        """
-        # Try to convert dict-like objects
-        try:
-            return {k: self._convert_args_to_dict(v) for k, v in args.items()}
-        except (AttributeError, TypeError):
-            # Try to convert list-like objects
-            try:
-                if isinstance(args, (str, bytes)):
-                    return args
-                return [self._convert_args_to_dict(item) for item in args]
-            except (TypeError, AttributeError):
-                # Base case: primitive value
-                return args
-
-    async def _private_request_async(
-        self,
-        messages: List[Dict],
-        temperature: float = 0,
-        model_name: str = "gemini-1.5-flash",
-        reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-        lm_config: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[str, Optional[List[Dict]]]:
-        generation_config = {
-            "temperature": temperature,
-        }
-        # Add max_output_tokens if max_tokens is in lm_config
-        if lm_config and "max_tokens" in lm_config:
-            generation_config["max_output_tokens"] = lm_config["max_tokens"]
-
-        tools_config = None
-        if tools:
-            tools_config = self._convert_tools_to_gemini_format(tools)
-
-        # Extract tool_config from lm_config if provided
-        tool_config = (
-            lm_config.get("tool_config")
-            if lm_config
-            else {"function_calling_config": {"mode": "any"}}
-        )
-
-        code_generation_model = genai.GenerativeModel(
-            model_name=model_name,
-            generation_config=generation_config,
-            tools=tools_config if tools_config else None,
-            tool_config=tool_config,
-        )
-
-        contents = self._convert_messages_to_contents(messages)
-        result = await code_generation_model.generate_content_async(
-            contents=contents,
-            safety_settings=SAFETY_SETTINGS,
-        )
-
-        text = result.candidates[0].content.parts[0].text
-        tool_calls = []
-        for part in result.candidates[0].content.parts:
-            if part.function_call:
-                # Convert complex objects to Python dictionaries recursively
-                args_dict = self._convert_args_to_dict(part.function_call.args)
-                # Ensure serializable arguments
-                tool_calls.append(
-                    {
-                        "id": f"call_{len(tool_calls) + 1}",  # Generate unique IDs
-                        "type": "function",
-                        "function": {
-                            "name": part.function_call.name,
-                            "arguments": json.dumps(args_dict),
-                        },
-                    }
-                )
-        return text, tool_calls if tool_calls else None
-
-    def _private_request_sync(
-        self,
-        messages: List[Dict],
-        temperature: float = 0,
-        model_name: str = "gemini-1.5-flash",
-        reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-        lm_config: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[str, Optional[List[Dict]]]:
-        generation_config = {
-            "temperature": temperature,
-        }
-        # Add max_output_tokens if max_tokens is in lm_config
-        if lm_config and "max_tokens" in lm_config:
-            generation_config["max_output_tokens"] = lm_config["max_tokens"]
-
-        tools_config = None
-        if tools:
-            tools_config = self._convert_tools_to_gemini_format(tools)
-
-        # Extract tool_config from lm_config if provided
-        tool_config = (
-            lm_config.get("tool_config")
-            if lm_config
-            else {"function_calling_config": {"mode": "any"}}
-        )
-
-        code_generation_model = genai.GenerativeModel(
-            model_name=model_name,
-            generation_config=generation_config,
-            tools=tools_config if tools_config else None,
-            tool_config=tool_config,
-        )
-
-        contents = self._convert_messages_to_contents(messages)
-        result = code_generation_model.generate_content(
-            contents=contents,
-            safety_settings=SAFETY_SETTINGS,
-        )
-
-        text = result.candidates[0].content.parts[0].text
-        tool_calls = []
-        for part in result.candidates[0].content.parts:
-            if part.function_call:
-                # Convert complex objects to Python dictionaries recursively
-                args_dict = self._convert_args_to_dict(part.function_call.args)
-                # Ensure serializable arguments
-                tool_calls.append(
-                    {
-                        "id": f"call_{len(tool_calls) + 1}",  # Generate unique IDs
-                        "type": "function",
-                        "function": {
-                            "name": part.function_call.name,
-                            "arguments": json.dumps(args_dict),
-                        },
-                    }
-                )
-        return text, tool_calls if tool_calls else None
-
-    @backoff.on_exception(
-        backoff.expo,
-        exceptions_to_retry,
-        max_tries=BACKOFF_TOLERANCE,
-        on_giveup=lambda e: print(e),
-    )
-    async def _hit_api_async(
-        self,
-        model: str,
-        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,
-    ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
-        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
-        cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools, reasoning_effort=reasoning_effort
-        )
-        if cache_result:
-            return cache_result
-
-        raw_response, tool_calls = await self._private_request_async(
-            messages,
-            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
-            reasoning_effort=reasoning_effort,
-            tools=tools,
-        )
-
-        lm_response = BaseLMResponse(
-            raw_response=raw_response,
-            structured_output=None,
-            tool_calls=tool_calls,
-        )
-
-        used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools, reasoning_effort=reasoning_effort
-        )
-        return lm_response
-
-    @backoff.on_exception(
-        backoff.expo,
-        exceptions_to_retry,
-        max_tries=BACKOFF_TOLERANCE,
-        on_giveup=lambda e: print(e),
-    )
-    def _hit_api_sync(
-        self,
-        model: str,
-        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,
-    ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
-        used_cache_handler = get_cache_handler(
-            use_ephemeral_cache_only=use_ephemeral_cache_only
-        )
-        cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools, reasoning_effort=reasoning_effort
-        )
-        if cache_result:
-            return cache_result
-
-        raw_response, tool_calls = self._private_request_sync(
-            messages,
-            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
-            reasoning_effort=reasoning_effort,
-            tools=tools,
-        )
-
-        lm_response = BaseLMResponse(
-            raw_response=raw_response,
-            structured_output=None,
-            tool_calls=tool_calls,
-        )
-
-        used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools, reasoning_effort=reasoning_effort
-        )
-        return lm_response

synth_ai/zyk/lms/vendors/core/mistral_api.py

@@ -1,327 +0,0 @@
-import json
-import os
-from typing import Any, Dict, List, Optional, Tuple, Type
-
-import pydantic
-from mistralai import Mistral  # use Mistral as both sync and async client
-from pydantic import BaseModel
-
-from synth_ai.zyk.lms.caching.initialize import get_cache_handler
-from synth_ai.zyk.lms.tools.base import BaseTool
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.zyk.lms.vendors.constants import SPECIAL_BASE_TEMPS
-from synth_ai.zyk.lms.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,)
-
-
-class MistralAPI(VendorBase):
-    used_for_structured_outputs: bool = True
-    exceptions_to_retry: Tuple = MISTRAL_EXCEPTIONS_TO_RETRY
-    _openai_fallback: Any
-
-    def __init__(
-        self,
-        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
-        self.exceptions_to_retry = exceptions_to_retry
-        self._openai_fallback = None
-
-    # @backoff.on_exception(
-    #     backoff.expo,
-    #     MISTRAL_EXCEPTIONS_TO_RETRY,
-    #     max_tries=BACKOFF_TOLERANCE,
-    #     on_giveup=lambda e: print(e),
-    # )
-    async def _hit_api_async(
-        self,
-        model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        response_model: Optional[BaseModel] = None,
-        use_ephemeral_cache_only: bool = False,
-        reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-    ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
-        assert not (response_model and tools), "Cannot provide both response_model and tools"
-        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
-        cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
-        )
-        if cache_result:
-            assert type(cache_result) in [
-                BaseLMResponse,
-                str,
-            ], f"Expected BaseLMResponse or str, got {type(cache_result)}"
-            return (
-                cache_result
-                if type(cache_result) == BaseLMResponse
-                else BaseLMResponse(
-                    raw_response=cache_result, structured_output=None, tool_calls=None
-                )
-            )
-
-        mistral_messages = [
-            {"role": msg["role"], "content": msg["content"]} for msg in messages
-        ]
-        functions = [tool.to_mistral_tool() for tool in tools] if tools else None
-        params = {
-            "model": model,
-            "messages": mistral_messages,
-            "max_tokens": lm_config.get("max_tokens", 4096),
-            "temperature": lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            ),
-            "stream": False,
-            "tool_choice": "auto" if functions else None,
-            
-        }
-        if response_model:
-            params["response_format"] = response_model
-        elif tools:
-            params["tools"] = functions
-
-        async with Mistral(api_key=os.getenv("MISTRAL_API_KEY", "")) as client:
-            response = await client.chat.complete_async(**params)
-
-        message = response.choices[0].message
-        try:
-            raw_response = message.content
-        except AttributeError:
-            raw_response = ""
-
-        tool_calls = []
-        try:
-            if message.tool_calls:
-                tool_calls = [
-                    {
-                        "id": call.id,
-                        "type": "function",
-                        "function": {
-                            "name": call.function.name,
-                            "arguments": call.function.arguments,
-                        },
-                    }
-                    for call in message.tool_calls
-                ]
-        except AttributeError:
-            pass
-
-        lm_response = BaseLMResponse(
-            raw_response=raw_response,
-            structured_output=None,
-            tool_calls=tool_calls if tool_calls else None,
-        )
-        used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
-        )
-        return lm_response
-
-    # @backoff.on_exception(
-    #     backoff.expo,
-    #     MISTRAL_EXCEPTIONS_TO_RETRY,
-    #     max_tries=BACKOFF_TOLERANCE,
-    #     on_giveup=lambda e: print(e),
-    # )
-    def _hit_api_sync(
-        self,
-        model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        response_model: Optional[BaseModel] = None,
-        use_ephemeral_cache_only: bool = False,
-        reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-    ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
-        assert not (response_model and tools), "Cannot provide both response_model and tools"
-       
-        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
-        cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
-        )
-        if cache_result:
-            assert type(cache_result) in [
-                BaseLMResponse,
-                str,
-            ], f"Expected BaseLMResponse or str, got {type(cache_result)}"
-            return (
-                cache_result
-                if type(cache_result) == BaseLMResponse
-                else BaseLMResponse(
-                    raw_response=cache_result, structured_output=None, tool_calls=None
-                )
-            )
-
-        mistral_messages = [
-            {"role": msg["role"], "content": msg["content"]} for msg in messages
-        ]
-        functions = [tool.to_mistral_tool() for tool in tools] if tools else None
-        
-        params = {
-            "model": model,
-            "messages": mistral_messages,
-            "max_tokens": lm_config.get("max_tokens", 4096),
-            "temperature": lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            ),
-            "stream": False,
-            "tool_choice": "auto" if functions else None,
-            #"tools": functions,
-        }
-        if response_model:
-            params["response_format"] = response_model
-        elif tools:
-            params["tools"] = functions
-
-        with Mistral(api_key=os.getenv("MISTRAL_API_KEY", "")) as client:
-            response = client.chat.complete(**params)
-
-        message = response.choices[0].message
-        try:
-            raw_response = message.content
-        except AttributeError:
-            raw_response = ""
-
-        tool_calls = []
-        try:
-            if message.tool_calls:
-                tool_calls = [
-                    {
-                        "id": call.id,
-                        "type": "function",
-                        "function": {
-                            "name": call.function.name,
-                            "arguments": call.function.arguments,
-                        },
-                    }
-                    for call in message.tool_calls
-                ]
-        except AttributeError:
-            pass
-
-        lm_response = BaseLMResponse(
-            raw_response=raw_response,
-            structured_output=None,
-            tool_calls=tool_calls if tool_calls else None,
-        )
-        used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
-        )
-        return lm_response
-
-    async def _hit_api_async_structured_output(
-        self,
-        model: str,
-        messages: List[Dict[str, Any]],
-        response_model: BaseModel,
-        temperature: float,
-        use_ephemeral_cache_only: bool = False,
-    ) -> BaseLMResponse:
-        try:
-            mistral_messages = [
-                {"role": msg["role"], "content": msg["content"]} for msg in messages
-            ]
-            async with Mistral(api_key=os.getenv("MISTRAL_API_KEY", "")) as client:
-                response = await client.chat.complete_async(
-                    model=model,
-                    messages=mistral_messages,
-                    max_tokens=4096,
-                    temperature=temperature,
-                    stream=False,
-                )
-            result = response.choices[0].message.content
-            parsed = json.loads(result)
-            lm_response = BaseLMResponse(
-                raw_response="",
-                structured_output=response_model(**parsed),
-                tool_calls=None,
-            )
-            return lm_response
-        except (json.JSONDecodeError, pydantic.ValidationError):
-            if self._openai_fallback is None:
-                self._openai_fallback = OpenAIStructuredOutputClient()
-            return await self._openai_fallback._hit_api_async_structured_output(
-                model="gpt-4o",
-                messages=messages,
-                response_model=response_model,
-                temperature=temperature,
-                use_ephemeral_cache_only=use_ephemeral_cache_only,
-            )
-
-    def _hit_api_sync_structured_output(
-        self,
-        model: str,
-        messages: List[Dict[str, Any]],
-        response_model: BaseModel,
-        temperature: float,
-        use_ephemeral_cache_only: bool = False,
-    ) -> BaseLMResponse:
-        try:
-            mistral_messages = [
-                {"role": msg["role"], "content": msg["content"]} for msg in messages
-            ]
-            with Mistral(api_key=os.getenv("MISTRAL_API_KEY", "")) as client:
-                response = client.chat.complete(
-                    model=model,
-                    messages=mistral_messages,
-                    max_tokens=4096,
-                    temperature=temperature,
-                    stream=False,
-                )
-            result = response.choices[0].message.content
-            parsed = json.loads(result)
-            lm_response = BaseLMResponse(
-                raw_response="",
-                structured_output=response_model(**parsed),
-                tool_calls=None,
-            )
-            return lm_response
-        except (json.JSONDecodeError, pydantic.ValidationError):
-            print("WARNING - Falling back to OpenAI - THIS IS SLOW")
-            if self._openai_fallback is None:
-                self._openai_fallback = OpenAIStructuredOutputClient()
-            return self._openai_fallback._hit_api_sync_structured_output(
-                model="gpt-4o",
-                messages=messages,
-                response_model=response_model,
-                temperature=temperature,
-                use_ephemeral_cache_only=use_ephemeral_cache_only,
-            )
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    from pydantic import BaseModel
-
-    class TestModel(BaseModel):
-        name: str
-
-    client = MistralAPI(used_for_structured_outputs=True, exceptions_to_retry=[])
-    import time
-
-    t = time.time()
-
-    async def run_async():
-        response = await client._hit_api_async_structured_output(
-            model="mistral-large-latest",
-            messages=[{"role": "user", "content": "What is the capital of the moon?"}],
-            response_model=TestModel,
-            temperature=0.0,
-        )
-        print(response)
-        return response
-
-    response = asyncio.run(run_async())
-    t2 = time.time()
-    print(f"Got {len(response.name)} chars in {t2-t} seconds")