synth-ai 0.1.0.dev39__py3-none-any.whl → 0.1.0.dev50__py3-none-any.whl

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

@@ -1,185 +0,0 @@
-import json
-from typing import Any, Dict, List, Optional, Tuple, Type
-
-import openai
-import pydantic_core
-
-# from openai import AsyncOpenAI, OpenAI
-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
-from synth_ai.zyk.lms.vendors.constants import SPECIAL_BASE_TEMPS, openai_reasoners
-from synth_ai.zyk.lms.vendors.openai_standard import OpenAIStandard
-
-OPENAI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (
-    pydantic_core._pydantic_core.ValidationError,
-    openai.OpenAIError,
-    openai.APIConnectionError,
-    openai.RateLimitError,
-    openai.APIError,
-    openai.Timeout,
-    openai.InternalServerError,
-    openai.APIConnectionError,
-)
-
-
-class OpenAIStructuredOutputClient(OpenAIStandard):
-    def __init__(self, synth_logging: bool = True):
-        if synth_logging:
-            # print("Using synth logging - OpenAIStructuredOutputClient")
-            from synth_sdk import AsyncOpenAI, OpenAI
-        else:
-            # print("Not using synth logging - OpenAIStructuredOutputClient")
-            from openai import AsyncOpenAI, OpenAI
-
-        super().__init__(
-            used_for_structured_outputs=True,
-            exceptions_to_retry=OPENAI_EXCEPTIONS_TO_RETRY,
-            sync_client=OpenAI(),
-            async_client=AsyncOpenAI(),
-        )
-
-    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,
-        tools: Optional[List[BaseTool]] = None,
-        reasoning_effort: str = "high",
-    ) -> str:
-        if tools:
-            raise ValueError("Tools are not supported for async structured output")
-        # "Hit client")
-        lm_config = {"temperature": temperature, "response_model": response_model}
-        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
-        )
-        if cache_result:
-            # print("Hit cache")
-            assert type(cache_result) in [
-                dict,
-                BaseLMResponse,
-            ], f"Expected dict or BaseLMResponse, got {type(cache_result)}"
-            return (
-                cache_result["response"] if type(cache_result) == dict else cache_result
-            )
-        if model in openai_reasoners:
-            output = await self.async_client.chat.completions.create(
-                model=model,
-                messages=messages,
-                temperature=temperature,
-                tools=tools,
-                max_completion_tokens=lm_config.get("max_tokens"),
-            )
-        else:
-            output = await self.async_client.chat.completions.create(
-                model=model,
-                messages=messages,
-                temperature=temperature,
-                max_tokens=lm_config.get("max_tokens"),
-            )
-        # "Output", output)
-        api_result = response_model(**json.loads(output.choices[0].message.content))
-        lm_response = BaseLMResponse(
-            raw_response="",
-            structured_output=api_result,
-            tool_calls=None,
-        )
-        used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config, output=lm_response
-        )
-        return lm_response
-
-    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,
-        tools: Optional[List[BaseTool]] = None,
-        reasoning_effort: str = "high",
-    ) -> str:
-        if tools:
-            raise ValueError("Tools are not supported for sync structured output")
-        lm_config = {"temperature": temperature, "response_model": response_model}
-        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
-        )
-        if cache_result:
-            assert type(cache_result) in [
-                dict,
-                BaseLMResponse,
-            ], f"Expected dict or BaseLMResponse, got {type(cache_result)}"
-            return (
-                cache_result["response"] if type(cache_result) == dict else cache_result
-            )
-        if model in ["o3-mini", "o3", "o1-mini", "o1"]:
-            output = self.sync_client.chat.completions.create(
-                model=model,
-                messages=messages,
-                temperature=temperature,
-                tools=tools,
-                max_tokens=lm_config.get("max_tokens"),
-            )
-        else:
-            output = self.sync_client.chat.completions.create(
-                model=model,
-                messages=messages,
-                temperature=temperature,
-                max_tokens=lm_config.get("max_tokens"),
-            )
-        api_result = response_model(**json.loads(output.choices[0].message.content))
-
-        lm_response = BaseLMResponse(
-            raw_response="",
-            structured_output=api_result,
-            tool_calls=None,
-        )
-        used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response
-        )
-        return lm_response
-
-
-class OpenAIPrivate(OpenAIStandard):
-    def __init__(self, synth_logging: bool = True):
-        if synth_logging:
-            # print("Using synth logging - OpenAIPrivate")
-            from synth_sdk import AsyncOpenAI, OpenAI
-        else:
-            # print("Not using synth logging - OpenAIPrivate")
-            from openai import AsyncOpenAI, OpenAI
-
-        self.sync_client = OpenAI()
-        self.async_client = AsyncOpenAI()
-
-
-if __name__ == "__main__":
-    client = OpenAIStructuredOutputClient(
-        sync_client=openai.OpenAI(),
-        async_client=openai.AsyncOpenAI(),
-        used_for_structured_outputs=True,
-        exceptions_to_retry=[],
-    )
-
-    class TestModel(BaseModel):
-        name: str
-
-    sync_model_response = client._hit_api_sync_structured_output(
-        model="gpt-4o-mini-2024-07-18",
-        messages=[{"role": "user", "content": " What is the capital of the moon?"}],
-        response_model=TestModel,
-        temperature=0.0,
-    )
-    # print(sync_model_response)

synth_ai/zyk/lms/vendors/openai_standard.py

@@ -1,374 +0,0 @@
-from typing import Any, Dict, List, Optional, Union
-
-import groq
-import openai
-import pydantic_core
-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, openai_reasoners
-
-DEFAULT_EXCEPTIONS_TO_RETRY = (
-    pydantic_core._pydantic_core.ValidationError,
-    openai.APIConnectionError,
-    openai.APITimeoutError,
-    groq.InternalServerError,
-    groq.APITimeoutError,
-    groq.APIConnectionError,
-)
-
-
-def special_orion_transform(
-    model: str, messages: List[Dict[str, Any]]
-) -> List[Dict[str, Any]]:
-    if "o1-" in model:
-        messages = [
-            {
-                "role": "user",
-                "content": f"<instructions>{messages[0]['content']}</instructions><information>{messages[1]}</information>",
-            }
-        ]
-    return messages
-
-
-def on_backoff_handler_async(details):
-    # Print every 5th retry attempt, excluding the first retry
-    if details["tries"] > 1 and (details["tries"] - 1) % 5 == 0:
-        print(f"Retrying async API call (attempt {details['tries'] - 1})")
-
-
-def on_backoff_handler_sync(details):
-    # Print every 5th retry attempt, excluding the first retry
-    if details["tries"] > 1 and (details["tries"] - 1) % 5 == 0:
-        print(f"Retrying sync API call (attempt {details['tries'] - 1})")
-
-
-class OpenAIStandard(VendorBase):
-    used_for_structured_outputs: bool = True
-    exceptions_to_retry: List = DEFAULT_EXCEPTIONS_TO_RETRY
-    sync_client: Any
-    async_client: Any
-
-    def __init__(
-        self,
-        sync_client: Any,
-        async_client: Any,
-        exceptions_to_retry: List[Exception] = DEFAULT_EXCEPTIONS_TO_RETRY,
-        used_for_structured_outputs: bool = False,
-    ):
-        self.sync_client = sync_client
-        self.async_client = async_client
-        self.used_for_structured_outputs = used_for_structured_outputs
-        self.exceptions_to_retry = exceptions_to_retry
-
-    # @backoff.on_exception(
-    #     backoff.expo,
-    #     exceptions_to_retry,
-    #     max_tries=BACKOFF_TOLERANCE,
-    #     on_backoff=on_backoff_handler_async,
-    #     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"
-        messages = special_orion_transform(model, messages)
-        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
-
-        # Common API call params
-        api_params = {
-            "model": model,
-            "messages": messages,
-        }
-        # Add max_tokens if present in lm_config
-        if "max_tokens" in lm_config:
-            api_params["max_completion_tokens"] = lm_config["max_tokens"]
-
-        # Add tools if provided
-        if tools:
-            api_params["tools"] = []
-            for tool in tools:
-                if isinstance(tool, BaseTool):
-                    api_params["tools"].append(tool.to_openai_tool())
-                else:
-                    api_params["tools"].append(tool)
-
-        # Only add temperature for non o1/o3 models
-        if model not in openai_reasoners:
-            api_params["temperature"] = lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            )
-
-        # Add reasoning_effort only for o3-mini
-        if model in openai_reasoners:
-            api_params["reasoning_effort"] = reasoning_effort
-
-        output = await self.async_client.chat.completions.create(**api_params)
-        message = output.choices[0].message
-
-        # Convert tool calls to dict format
-        tool_calls = None
-        if message.tool_calls:
-            tool_calls = [
-                {
-                    "id": tc.id,
-                    "type": tc.type,
-                    "function": {
-                        "name": tc.function.name,
-                        "arguments": tc.function.arguments,
-                    },
-                }
-                for tc in message.tool_calls
-            ]
-
-        lm_response = BaseLMResponse(
-            raw_response=message.content or "",  # Use empty string if no content
-            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_backoff=on_backoff_handler_sync,
-    #     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"
-        messages = special_orion_transform(model, messages)
-        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
-
-        # Common API call params
-        api_params = {
-            "model": model,
-            "messages": messages,
-        }
-        # Add max_tokens if present in lm_config
-        if "max_tokens" in lm_config:
-            api_params["max_tokens"] = lm_config["max_tokens"]
-
-        # Add tools if provided
-        if tools:
-            api_params["tools"] = []
-            for tool in tools:
-                if isinstance(tool, BaseTool):
-                    api_params["tools"].append(tool.to_openai_tool())
-                else:
-                    api_params["tools"].append(tool)
-
-        # Only add temperature for non o1/o3 models
-        if model not in openai_reasoners:
-            api_params["temperature"] = lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            )
-
-        # Add reasoning_effort only for o3-mini
-        if model in openai_reasoners:
-            api_params["reasoning_effort"] = reasoning_effort
-
-        output = self.sync_client.chat.completions.create(**api_params)
-        message = output.choices[0].message
-
-        # Convert tool calls to dict format
-        tool_calls = None
-        if message.tool_calls:
-            tool_calls = [
-                {
-                    "id": tc.id,
-                    "type": tc.type,
-                    "function": {
-                        "name": tc.function.name,
-                        "arguments": tc.function.arguments,
-                    },
-                }
-                for tc in message.tool_calls
-            ]
-
-        lm_response = BaseLMResponse(
-            raw_response=message.content or "",  # Use empty string if no content
-            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
-
-    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,
-        reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-    ) -> BaseLMResponse:
-        lm_config = {"temperature": temperature, "response_model": response_model}
-        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
-        cache_result: Union[BaseLMResponse, None] = (
-            used_cache_handler.hit_managed_cache(
-                model,
-                messages,
-                lm_config=lm_config,
-                tools=tools,
-                reasoning_effort=reasoning_effort,
-            )
-        )
-        if cache_result is not None:
-            return cache_result
-
-        # Common API call params
-        api_params = {
-            "model": model,
-            "messages": messages,
-        }
-
-        # Add tools if provided
-        if tools:
-            api_params["tools"] = []
-            for tool in tools:
-                if isinstance(tool, BaseTool):
-                    api_params["tools"].append(tool.to_openai_tool())
-                else:
-                    api_params["tools"].append(tool)
-
-        # Only add temperature for non o1/o3 models
-        if model not in openai_reasoners:
-            api_params["temperature"] = lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            )
-
-        # Add reasoning_effort only for o3-mini
-        if model in openai_reasoners:
-            api_params["reasoning_effort"] = reasoning_effort
-
-        output = await self.async_client.chat.completions.create(**api_params)
-
-        structured_output_api_result = response_model(
-            **output.choices[0].message.content
-        )
-        tool_calls = output.choices[0].message.tool_calls
-        lm_response = BaseLMResponse(
-            raw_response=output.choices[0].message.content,
-            structured_output=structured_output_api_result,
-            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
-
-    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,
-        reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-    ) -> BaseLMResponse:
-        lm_config = {"temperature": temperature, "response_model": response_model}
-        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
-        cache_result: Union[BaseLMResponse, None] = (
-            used_cache_handler.hit_managed_cache(
-                model,
-                messages,
-                lm_config=lm_config,
-                tools=tools,
-                reasoning_effort=reasoning_effort,
-            )
-        )
-        if cache_result is not None:
-            return cache_result
-
-        # Common API call params
-        api_params = {
-            "model": model,
-            "messages": messages,
-        }
-
-        # Add tools if provided
-        if tools:
-            api_params["tools"] = []
-            for tool in tools:
-                if isinstance(tool, BaseTool):
-                    api_params["tools"].append(tool.to_openai_tool())
-                else:
-                    api_params["tools"].append(tool)
-
-        # Only add temperature for non o1/o3 models
-        if model not in openai_reasoners:
-            api_params["temperature"] = lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            )
-
-        # Add reasoning_effort only for o3-mini
-        if model in openai_reasoners:
-            api_params["reasoning_effort"] = reasoning_effort
-
-        output = self.sync_client.chat.completions.create(**api_params)
-
-        structured_output_api_result = response_model(
-            **output.choices[0].message.content
-        )
-        tool_calls = output.choices[0].message.tool_calls
-        lm_response = BaseLMResponse(
-            raw_response=output.choices[0].message.content,
-            structured_output=structured_output_api_result,
-            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/retries.py

@@ -1,3 +0,0 @@
-import backoff
-
-BACKOFF_TOLERANCE = 20

synth_ai/zyk/lms/vendors/supported/deepseek.py

@@ -1,73 +0,0 @@
-import os
-from typing import Any, Dict, List, Optional, Tuple
-
-from openai import AsyncOpenAI, OpenAI
-
-from synth_ai.zyk.lms.tools.base import BaseTool
-from synth_ai.zyk.lms.vendors.openai_standard import OpenAIStandard
-
-
-class DeepSeekAPI(OpenAIStandard):
-    def __init__(self):
-        # print("Setting up DeepSeek API")
-        self.sync_client = OpenAI(
-            api_key=os.environ.get("DEEPSEEK_API_KEY"),
-            base_url="https://api.deepseek.com",
-        )
-        self.async_client = AsyncOpenAI(
-            api_key=os.environ.get("DEEPSEEK_API_KEY"),
-            base_url="https://api.deepseek.com",
-        )
-
-    def _convert_tools_to_openai_format(self, tools: List[BaseTool]) -> List[Dict]:
-        return [tool.to_openai_tool() for tool in tools]
-
-    async def _private_request_async(
-        self,
-        messages: List[Dict],
-        temperature: float = 0,
-        model_name: str = "deepseek-chat",
-        reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-        lm_config: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[str, Optional[List[Dict]]]:
-        request_params = {
-            "model": model_name,
-            "messages": messages,
-            "temperature": temperature,
-        }
-
-        if tools:
-            request_params["tools"] = self._convert_tools_to_openai_format(tools)
-
-        response = await self.async_client.chat.completions.create(**request_params)
-        message = response.choices[0].message
-
-        return message.content, message.tool_calls if hasattr(
-            message, "tool_calls"
-        ) else None
-
-    def _private_request_sync(
-        self,
-        messages: List[Dict],
-        temperature: float = 0,
-        model_name: str = "deepseek-chat",
-        reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-        lm_config: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[str, Optional[List[Dict]]]:
-        request_params = {
-            "model": model_name,
-            "messages": messages,
-            "temperature": temperature,
-        }
-
-        if tools:
-            request_params["tools"] = self._convert_tools_to_openai_format(tools)
-
-        response = self.sync_client.chat.completions.create(**request_params)
-        message = response.choices[0].message
-
-        return message.content, message.tool_calls if hasattr(
-            message, "tool_calls"
-        ) else None

synth_ai/zyk/lms/vendors/supported/groq.py

@@ -1,16 +0,0 @@
-import os
-
-from dotenv import load_dotenv
-from groq import AsyncGroq, Groq
-
-from synth_ai.zyk.lms.vendors.openai_standard import OpenAIStandard
-
-load_dotenv()
-
-
-class GroqAPI(OpenAIStandard):
-    def __init__(self):
-        super().__init__(
-            sync_client=Groq(api_key=os.getenv("GROQ_API_KEY")),
-            async_client=AsyncGroq(api_key=os.getenv("GROQ_API_KEY")),
-        )

synth_ai/zyk/lms/vendors/supported/ollama.py

@@ -1,14 +0,0 @@
-from openai import OpenAI, AsyncOpenAI
-from synth_ai.zyk.lms.vendors.openai_standard import OpenAIStandard
-
-
-class OllamaAPI(OpenAIStandard):
-    def __init__(self):
-        self.sync_client = OpenAI(
-            base_url="http://localhost:11434/v1",
-            api_key="ollama",  # required, but unused
-        )
-        self.async_client = AsyncOpenAI(
-            base_url="http://localhost:11434/v1",
-            api_key="ollama",  # required, but unused
-        )

synth_ai/zyk/lms/vendors/supported/together.py

@@ -1,11 +0,0 @@
-import os
-
-from together import AsyncTogether, Together
-
-from synth_ai.zyk.lms.vendors.openai_standard import OpenAIStandard
-
-
-class TogetherAPI(OpenAIStandard):
-    def __init__(self):
-        self.sync_client = Together(api_key=os.getenv("TOGETHER_API_KEY"))
-        self.async_client = AsyncTogether(api_key=os.getenv("TOGETHER_API_KEY"))