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

synth_ai/zyk/lms/caching/handler.py

@@ -1,142 +0,0 @@
-import hashlib
-from typing import Any, Dict, List, Optional, Type
-
-from pydantic import BaseModel
-
-from synth_ai.zyk.lms.caching.ephemeral import EphemeralCache
-from synth_ai.zyk.lms.caching.persistent import PersistentCache
-from synth_ai.zyk.lms.tools.base import BaseTool
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse
-
-persistent_cache = PersistentCache()
-ephemeral_cache = EphemeralCache()
-
-
-def map_params_to_key(
-    messages: List[Dict],
-    model: str,
-    temperature: float,
-    response_model: Optional[Type[BaseModel]],
-    tools: Optional[List] = None,
-    reasoning_effort: Optional[str] = None,
-    max_tokens: Optional[int] = None,
-) -> str:
-    if not all([isinstance(msg["content"], str) for msg in messages]):
-        normalized_messages = "".join([str(msg["content"]) for msg in messages])
-    else:
-        normalized_messages = "".join([msg["content"] for msg in messages])
-    normalized_model = model
-    normalized_temperature = f"{temperature:.2f}"[:4]
-    normalized_response_model = str(response_model.schema()) if response_model else ""
-    normalized_reasoning_effort = str(reasoning_effort) if reasoning_effort is not None else ""
-    normalized_max_tokens = str(max_tokens) if max_tokens is not None else ""
-
-    # Normalize tools if present
-    normalized_tools = ""
-    if tools:
-        tool_schemas = []
-        for tool in tools:
-            tool_schema = {}
-            try:
-                tool_schema = {
-                    "name": tool.name,
-                    "description": tool.description,
-                    "arguments": tool.arguments.model_json_schema(),
-                }
-            except AttributeError:
-                if isinstance(tool, dict) and "name" in tool:
-                    tool_schema = {
-                        "name": tool.get("name", ""),
-                        "description": tool.get("description", ""),
-                        "parameters": tool.get("parameters", {}),
-                    }
-
-            tool_schemas.append(str(tool_schema))
-        normalized_tools = "".join(tool_schemas)
-
-    return hashlib.sha256(
-        (
-            normalized_messages
-            + normalized_model
-            + normalized_temperature
-            + normalized_response_model
-            + normalized_tools
-            + normalized_reasoning_effort
-            + normalized_max_tokens
-        ).encode()
-    ).hexdigest()
-
-
-class CacheHandler:
-    use_persistent_store: bool = False
-    use_ephemeral_store: bool = True
-
-    def __init__(
-        self, use_persistent_store: bool = False, use_ephemeral_store: bool = True
-    ):
-        self.use_persistent_store = use_persistent_store
-        self.use_ephemeral_store = use_ephemeral_store
-
-    def _validate_messages(self, messages: List[Dict[str, Any]]) -> None:
-        """Validate that messages are in the correct format."""
-        assert all(
-            [type(msg["content"]) == str for msg in messages]
-        ), "All message contents must be strings"
-
-    def hit_managed_cache(
-        self,
-        model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        tools: Optional[List] = None,
-        reasoning_effort: Optional[str] = None,
-    ) -> Optional[BaseLMResponse]:
-        """Hit the cache with the given key."""
-        self._validate_messages(messages)
-        assert type(lm_config) == dict, "lm_config must be a dictionary"
-        key = map_params_to_key(
-            messages,
-            model,
-            lm_config.get("temperature", 0.0),
-            lm_config.get("response_model", None),
-            tools,
-            reasoning_effort,
-            lm_config.get("max_tokens"),
-        )
-        if self.use_persistent_store:
-            return persistent_cache.hit_cache(
-                key=key, response_model=lm_config.get("response_model", None)
-            )
-        elif self.use_ephemeral_store:
-            return ephemeral_cache.hit_cache(
-                key=key, response_model=lm_config.get("response_model", None)
-            )
-        else:
-            return None
-
-    def add_to_managed_cache(
-        self,
-        model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        output: BaseLMResponse,
-        tools: Optional[List] = None,
-        reasoning_effort: Optional[str] = None,
-    ) -> None:
-        """Add the given output to the cache."""
-        self._validate_messages(messages)
-        assert type(output) == BaseLMResponse, "output must be a BaseLMResponse"
-        assert type(lm_config) == dict, "lm_config must be a dictionary"
-        key = map_params_to_key(
-            messages,
-            model,
-            lm_config.get("temperature", 0.0),
-            lm_config.get("response_model", None),
-            tools,
-            reasoning_effort,
-            lm_config.get("max_tokens"),
-        )
-        if self.use_persistent_store:
-            persistent_cache.add_to_cache(key, output)
-        if self.use_ephemeral_store:
-            ephemeral_cache.add_to_cache(key, output)

synth_ai/zyk/lms/caching/initialize.py

@@ -1,13 +0,0 @@
-from synth_ai.zyk.lms.caching.handler import CacheHandler
-
-cache_handler = CacheHandler(use_ephemeral_store=True, use_persistent_store=True)
-ephemeral_cache_handler = CacheHandler(
-    use_ephemeral_store=True, use_persistent_store=False
-)
-
-
-def get_cache_handler(use_ephemeral_cache_only: bool = False):
-    if use_ephemeral_cache_only:
-        return ephemeral_cache_handler
-    else:
-        return cache_handler

synth_ai/zyk/lms/caching/persistent.py

@@ -1,83 +0,0 @@
-import json
-import os
-import sqlite3
-from dataclasses import dataclass
-from typing import Optional, Type, Union
-
-from pydantic import BaseModel
-
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse
-
-
-@dataclass
-class PersistentCache:
-    def __init__(self, db_path: str = ".cache/persistent_cache.db"):
-        os.makedirs(os.path.dirname(db_path), exist_ok=True)
-        self.conn = sqlite3.connect(db_path)
-        self.cursor = self.conn.cursor()
-        self.cursor.execute("""CREATE TABLE IF NOT EXISTS cache
-                              (key TEXT PRIMARY KEY, response TEXT)""")
-        self.conn.commit()
-
-    def hit_cache(
-        self, key: str, response_model: Optional[Type[BaseModel]] = None
-    ) -> Optional[BaseLMResponse]:
-        self.cursor.execute("SELECT response FROM cache WHERE key = ?", (key,))
-        result = self.cursor.fetchone()
-        if not result:
-            return None
-
-        try:
-            cache_data = json.loads(result[0])
-        except json.JSONDecodeError:
-            # Handle legacy string responses
-            return BaseLMResponse(
-                raw_response=result[0], structured_output=None, tool_calls=None
-            )
-
-        if not isinstance(cache_data, dict):
-            return BaseLMResponse(
-                raw_response=cache_data, structured_output=None, tool_calls=None
-            )
-
-        raw_response = cache_data.get("raw_response")
-        tool_calls = cache_data.get("tool_calls")
-        structured_output = cache_data.get("structured_output")
-
-        if response_model and structured_output:
-            structured_output = response_model(**structured_output)
-
-        return BaseLMResponse(
-            raw_response=raw_response,
-            structured_output=structured_output,
-            tool_calls=tool_calls,
-        )
-
-    def add_to_cache(self, key: str, response: Union[BaseLMResponse, str]) -> None:
-        if isinstance(response, str):
-            cache_data = response
-        elif isinstance(response, BaseLMResponse):
-            cache_data = {
-                "raw_response": response.raw_response
-                if response.raw_response is not None
-                else None,
-                "tool_calls": response.tool_calls
-                if response.tool_calls is not None
-                else None,
-                "structured_output": (
-                    response.structured_output.model_dump()
-                    if response.structured_output is not None
-                    else None
-                ),
-            }
-        else:
-            raise ValueError(f"Invalid response type: {type(response)}")
-
-        self.cursor.execute(
-            "INSERT OR REPLACE INTO cache (key, response) VALUES (?, ?)",
-            (key, json.dumps(cache_data)),
-        )
-        self.conn.commit()
-
-    def close(self) -> None:
-        self.conn.close()

synth_ai/zyk/lms/config.py

@@ -1,8 +0,0 @@
-import os
-from dotenv import load_dotenv
-
-
-def should_use_cache() -> bool:
-    load_dotenv()
-    cache_env = os.getenv("USE_ZYK_CACHE", "true").lower()
-    return cache_env not in ("false", "0", "no")

synth_ai/zyk/lms/core/all.py

@@ -1,47 +0,0 @@
-from synth_ai.zyk.lms.vendors.core.anthropic_api import AnthropicAPI
-from synth_ai.zyk.lms.vendors.core.gemini_api import GeminiAPI
-from synth_ai.zyk.lms.vendors.core.openai_api import (
-    OpenAIPrivate,
-    OpenAIStructuredOutputClient,
-)
-from synth_ai.zyk.lms.vendors.supported.deepseek import DeepSeekAPI
-from synth_ai.zyk.lms.vendors.supported.together import TogetherAPI
-from synth_ai.zyk.lms.vendors.supported.groq import GroqAPI
-from synth_ai.zyk.lms.vendors.core.mistral_api import MistralAPI
-
-
-class OpenAIClient(OpenAIPrivate):
-    def __init__(self, synth_logging: bool = True):
-        super().__init__(
-            synth_logging=synth_logging,
-        )
-
-
-class AnthropicClient(AnthropicAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class GeminiClient(GeminiAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class DeepSeekClient(DeepSeekAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class TogetherClient(TogetherAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class GroqClient(GroqAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class MistralClient(MistralAPI):
-    def __init__(self):
-        super().__init__()

synth_ai/zyk/lms/core/exceptions.py

@@ -1,9 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
-
-
-class StructuredOutputCoercionFailureException(Exception):
-    pass
-
-
-# ... rest of imports ...

synth_ai/zyk/lms/core/main.py

@@ -1,314 +0,0 @@
-from typing import Any, Dict, List, Literal, Optional
-
-from pydantic import BaseModel, Field
-
-from synth_ai.zyk.lms.core.exceptions import StructuredOutputCoercionFailureException
-from synth_ai.zyk.lms.core.vendor_clients import (
-    anthropic_naming_regexes,
-    get_client,
-    openai_naming_regexes,
-)
-from synth_ai.zyk.lms.structured_outputs.handler import StructuredOutputHandler
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
-
-REASONING_MODELS = ["deepseek-reasoner", "o1-mini", "o1-preview", "o1", "o3", "o4-mini", "claude-3-7-latest-thinking", "gemini-1.5-pro-latest"]
-
-
-def build_messages(
-    sys_msg: str,
-    user_msg: str,
-    images_bytes: List = [],
-    model_name: Optional[str] = None,
-) -> List[Dict]:
-    if len(images_bytes) > 0 and any(
-        regex.match(model_name) for regex in openai_naming_regexes
-    ):
-        return [
-            {"role": "system", "content": sys_msg},
-            {
-                "role": "user",
-                "content": [{"type": "text", "text": user_msg}]
-                + [
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/jpeg;base64,{image_bytes}"},
-                    }
-                    for image_bytes in images_bytes
-                ],
-            },
-        ]
-    elif len(images_bytes) > 0 and any(
-        regex.match(model_name) for regex in anthropic_naming_regexes
-    ):
-        system_info = {"role": "system", "content": sys_msg}
-        user_info = {
-            "role": "user",
-            "content": [{"type": "text", "text": user_msg}]
-            + [
-                {
-                    "type": "image",
-                    "source": {
-                        "type": "base64",
-                        "media_type": "image/png",
-                        "data": image_bytes,
-                    },
-                }
-                for image_bytes in images_bytes
-            ],
-        }
-        return [system_info, user_info]
-    elif len(images_bytes) > 0:
-        raise ValueError("Images are not yet supported for this model")
-    else:
-        return [
-            {"role": "system", "content": sys_msg},
-            {"role": "user", "content": user_msg},
-        ]
-
-
-class LM:
-    # if str
-    model_name: str
-    client: VendorBase
-    lm_config: Dict[str, Any]
-    structured_output_handler: StructuredOutputHandler
-
-    def __init__(
-        self,
-        model_name: str,
-        formatting_model_name: str,
-        temperature: float,
-        max_retries: Literal["None", "Few", "Many"] = "Few",
-        structured_output_mode: Literal[
-            "stringified_json", "forced_json"
-        ] = "stringified_json",
-        synth_logging: bool = True,
-    ):
-        # print("Structured output mode", structured_output_mode)
-        self.client = get_client(
-            model_name,
-            with_formatting=structured_output_mode == "forced_json",
-            synth_logging=synth_logging,
-        )
-        # print(self.client.__class__)
-
-        # Determine if the primary model supports forced JSON or specific formatting modes
-       # primary_model_supports_forced_json = self.client.supports_forced_json()
-
-        # Choose the structured output mode based on primary model capability
-        # effective_structured_output_mode = structured_output_mode
-        # if not primary_model_supports_forced_json and structured_output_mode == "forced_json":
-        #     # Fallback or adjust if the primary model doesn't support the desired mode
-        #     # For simplicity, let's assume we might want to fallback to stringified_json or handle differently
-        #     # print(f"Warning: Model {model_name} does not support forced_json. Adjusting strategy.")
-        #     effective_structured_output_mode = "stringified_json" # Example fallback
-
-
-        formatting_client = get_client(formatting_model_name, with_formatting=True)
-
-
-        max_retries_dict = {"None": 0, "Few": 2, "Many": 5}
-        # Use the effective mode for the primary handler
-        self.structured_output_handler = StructuredOutputHandler(
-            self.client,
-            formatting_client,
-            structured_output_mode, # Use original mode
-            {"max_retries": max_retries_dict.get(max_retries, 2)},
-        )
-         # Always have a forced_json backup handler ready
-        self.backup_structured_output_handler = StructuredOutputHandler(
-            self.client, # This should ideally use a client capable of forced_json if primary isn't
-            formatting_client, # Formatting client must support forced_json
-            "forced_json",
-            {"max_retries": max_retries_dict.get(max_retries, 2)},
-        )
-        # Override temperature to 1 for reasoning models
-        effective_temperature = 1.0 if model_name in REASONING_MODELS else temperature
-        self.lm_config = {"temperature": effective_temperature}
-        self.model_name = model_name
-
-    def respond_sync(
-        self,
-        system_message: Optional[str] = None,
-        user_message: Optional[str] = None,
-        messages: Optional[List[Dict]] = None,
-        images_as_bytes: List[Any] = [],
-        response_model: Optional[BaseModel] = None,
-        use_ephemeral_cache_only: bool = False,
-        tools: Optional[List] = None,
-        reasoning_effort: Optional[str] = None,
-    ) -> BaseLMResponse:
-        assert (system_message is None) == (
-            user_message is None
-        ), "Must provide both system_message and user_message or neither"
-        assert (
-            (messages is None) != (system_message is None)
-        ), "Must provide either messages or system_message/user_message pair, but not both"
-        assert not (
-            response_model and tools
-        ), "Cannot provide both response_model and tools"
-
-        current_lm_config = self.lm_config.copy()
-        if self.model_name in REASONING_MODELS:
-            # Removed logic that set max_tokens based on reasoning_tokens
-            # Vendor clients will now receive reasoning_effort directly
-            pass
-
-
-        if messages is None:
-            messages = build_messages(
-                system_message, user_message, images_as_bytes, self.model_name
-            )
-        result = None
-        if response_model:
-            try:
-                result = self.structured_output_handler.call_sync(
-                    messages=messages,
-                    model=self.model_name,
-                    response_model=response_model,
-                    use_ephemeral_cache_only=use_ephemeral_cache_only,
-                    lm_config=current_lm_config,
-                    reasoning_effort=reasoning_effort,
-                )
-            except StructuredOutputCoercionFailureException:
-                # print("Falling back to backup handler")
-                result = self.backup_structured_output_handler.call_sync(
-                    messages=messages,
-                    model=self.model_name,
-                    response_model=response_model,
-                    use_ephemeral_cache_only=use_ephemeral_cache_only,
-                    lm_config=current_lm_config,
-                    reasoning_effort=reasoning_effort,
-                )
-        else:
-            result = self.client._hit_api_sync(
-                messages=messages,
-                model=self.model_name,
-                lm_config=current_lm_config,
-                use_ephemeral_cache_only=use_ephemeral_cache_only,
-                tools=tools,
-                reasoning_effort=reasoning_effort,
-            )
-        assert isinstance(result.raw_response, str), "Raw response must be a string"
-        assert (
-            isinstance(result.structured_output, BaseModel)
-            or result.structured_output is None
-        ), "Structured output must be a Pydantic model or None"
-        assert (
-            isinstance(result.tool_calls, list) or result.tool_calls is None
-        ), "Tool calls must be a list or None"
-        return result
-
-    async def respond_async(
-        self,
-        system_message: Optional[str] = None,
-        user_message: Optional[str] = None,
-        messages: Optional[List[Dict]] = None,
-        images_as_bytes: List[Any] = [],
-        response_model: Optional[BaseModel] = None,
-        use_ephemeral_cache_only: bool = False,
-        tools: Optional[List] = None,
-        reasoning_effort: Optional[str] = None,
-    ) -> BaseLMResponse:
-        # "In respond_async")
-        assert (system_message is None) == (
-            user_message is None
-        ), "Must provide both system_message and user_message or neither"
-        assert (
-            (messages is None) != (system_message is None)
-        ), "Must provide either messages or system_message/user_message pair, but not both"
-
-        assert not (
-            response_model and tools
-        ), "Cannot provide both response_model and tools"
-
-        current_lm_config = self.lm_config.copy()
-        if self.model_name in REASONING_MODELS:
-            # Removed logic that set max_tokens based on reasoning_tokens
-            # Vendor clients will now receive reasoning_effort directly
-            pass
-
-        if messages is None:
-            messages = build_messages(
-                system_message, user_message, images_as_bytes, self.model_name
-            )
-        result = None
-        if response_model:
-            try:
-                # print("Trying structured output handler")
-                result = await self.structured_output_handler.call_async(
-                    messages=messages,
-                    model=self.model_name,
-                    response_model=response_model,
-                    use_ephemeral_cache_only=use_ephemeral_cache_only,
-                    lm_config=current_lm_config,
-                    reasoning_effort=reasoning_effort,
-                )
-            except StructuredOutputCoercionFailureException:
-                # print("Falling back to backup handler")
-                result = await self.backup_structured_output_handler.call_async(
-                    messages=messages,
-                    model=self.model_name,
-                    response_model=response_model,
-                    use_ephemeral_cache_only=use_ephemeral_cache_only,
-                    lm_config=current_lm_config,
-                    reasoning_effort=reasoning_effort,
-                )
-        else:
-            # print("Calling API no response model")
-            result = await self.client._hit_api_async(
-                messages=messages,
-                model=self.model_name,
-                lm_config=current_lm_config,
-                use_ephemeral_cache_only=use_ephemeral_cache_only,
-                tools=tools,
-                reasoning_effort=reasoning_effort,
-            )
-        assert isinstance(result.raw_response, str), "Raw response must be a string"
-        assert (
-            isinstance(result.structured_output, BaseModel)
-            or result.structured_output is None
-        ), "Structured output must be a Pydantic model or None"
-        assert (
-            isinstance(result.tool_calls, list) or result.tool_calls is None
-        ), "Tool calls must be a list or None"
-        return result
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    # Update json instructions to handle nested pydantic?
-    class Thought(BaseModel):
-        argument_keys: List[str] = Field(description="The keys of the arguments")
-        argument_values: List[str] = Field(
-            description="Stringified JSON for the values of the arguments"
-        )
-
-    class TestModel(BaseModel):
-        emotion: str = Field(description="The emotion expressed")
-        concern: str = Field(description="The concern expressed")
-        action: str = Field(description="The action to be taken")
-        thought: Thought = Field(description="The thought process")
-
-        class Config:
-            schema_extra = {"required": ["thought", "emotion", "concern", "action"]}
-
-    lm = LM(
-        model_name="gpt-4o-mini",
-        formatting_model_name="gpt-4o-mini",
-        temperature=1,
-        max_retries="Few",
-        structured_output_mode="forced_json",
-    )
-    print(
-        asyncio.run(
-            lm.respond_async(
-                system_message="You are a helpful assistant ",
-                user_message="Hello, how are you?",
-                images_as_bytes=[],
-                response_model=TestModel,
-                use_ephemeral_cache_only=False,
-            )
-        )
-    )