synth-ai 0.1.0.dev4__py3-none-any.whl → 0.1.0.dev6__py3-none-any.whl

public_tests/test_recursive_structured_outputs.py

@@ -0,0 +1,180 @@
+import asyncio
+import unittest
+from typing import List
+
+from pydantic import BaseModel, Field
+
+from synth_ai.zyk.lms.core.main import LM
+
+
+# Define example structured output models
+class SimpleResponse(BaseModel):
+    message: str
+    confidence: float
+
+
+class ComplexResponse(BaseModel):
+    title: str
+    tags: List[str]
+    content: str
+
+
+class NestedResponse(BaseModel):
+    main_category: str
+    subcategories: List[str]
+    details: SimpleResponse
+
+
+# Define nested structured output models
+class Address(BaseModel):
+    street: str
+    city: str
+    country: str
+
+
+class PersonalInfo(BaseModel):
+    name: str
+    age: int
+    address: Address
+
+
+class WorkInfo(BaseModel):
+    company: str
+    position: str
+    years_experience: int
+
+
+class NestedPersonResponse(BaseModel):
+    personal: PersonalInfo
+    work: WorkInfo
+    skills: List[str]
+
+
+class ProjectDetails(BaseModel):
+    name: str
+    description: str
+    technologies: List[str]
+
+
+class NestedPortfolioResponse(BaseModel):
+    developer: PersonalInfo
+    projects: List[ProjectDetails]
+    total_experience: int
+
+
+class NestedCompanyResponse(BaseModel):
+    name: str
+    founded: int
+    headquarters: Address
+    employees: List[PersonalInfo]
+    main_products: List[str]
+
+
+class TestLMStructuredOutputs(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # Initialize the LM once for all tests
+        cls.lm = LM(
+            model_name="gpt-4o-mini",
+            formatting_model_name="gpt-4o-mini",
+            temperature=0.7,
+            max_retries="Few",
+            structured_output_mode="forced_json",
+        )
+
+    def test_sync_simple_response(self):
+        result = self.lm.respond_sync(
+            system_message="You are a helpful assistant.",
+            user_message="Give me a short greeting and your confidence level.",
+            response_model=SimpleResponse,
+        )
+        self.assertIsInstance(result, SimpleResponse)
+        self.assertIsInstance(result.message, str)
+        self.assertIsInstance(result.confidence, float)
+        self.assertGreaterEqual(result.confidence, 0)
+        self.assertLessEqual(result.confidence, 1)
+
+    def test_sync_complex_response(self):
+        result = self.lm.respond_sync(
+            system_message="You are a content creator.",
+            user_message="Create a short blog post about AI.",
+            response_model=ComplexResponse,
+        )
+        self.assertIsInstance(result, ComplexResponse)
+        self.assertIsInstance(result.title, str)
+        self.assertIsInstance(result.tags, list)
+        self.assertIsInstance(result.content, str)
+
+    async def async_nested_response(self):
+        result = await self.lm.respond_async(
+            system_message="You are a categorization expert.",
+            user_message="Categorize 'Python' and provide a brief description.",
+            response_model=NestedResponse,
+        )
+        self.assertIsInstance(result, NestedResponse)
+        self.assertIsInstance(result.main_category, str)
+        self.assertIsInstance(result.subcategories, list)
+        self.assertIsInstance(result.details, SimpleResponse)
+
+    def test_async_nested_response(self):
+        asyncio.run(self.async_nested_response())
+
+
+class TestLMNestedStructuredOutputs(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # Initialize the LM once for all tests
+        cls.lm = LM(
+            model_name="gpt-4o-mini",
+            formatting_model_name="gpt-4o-mini",
+            temperature=0.7,
+            max_retries="Few",
+            structured_output_mode="forced_json",
+        )
+
+    def test_sync_nested_person_response(self):
+        result = self.lm.respond_sync(
+            system_message="You are an HR assistant.",
+            user_message="Provide detailed information about a fictional employee named John Doe.",
+            response_model=NestedPersonResponse,
+        )
+        self.assertIsInstance(result, NestedPersonResponse)
+        self.assertIsInstance(result.personal, PersonalInfo)
+        self.assertIsInstance(result.personal.address, Address)
+        self.assertIsInstance(result.work, WorkInfo)
+        self.assertIsInstance(result.skills, list)
+
+    def test_sync_nested_portfolio_response(self):
+        result = self.lm.respond_sync(
+            system_message="You are a portfolio manager.",
+            user_message="Create a portfolio for a fictional software developer with multiple projects.",
+            response_model=NestedPortfolioResponse,
+        )
+        self.assertIsInstance(result, NestedPortfolioResponse)
+        self.assertIsInstance(result.developer, PersonalInfo)
+        self.assertIsInstance(result.developer.address, Address)
+        self.assertIsInstance(result.projects, list)
+        for project in result.projects:
+            self.assertIsInstance(project, ProjectDetails)
+        self.assertIsInstance(result.total_experience, int)
+
+    async def async_nested_company_response(self):
+        result = await self.lm.respond_async(
+            system_message="You are a company information specialist.",
+            user_message="Provide detailed information about a fictional tech company.",
+            response_model=NestedCompanyResponse,
+        )
+        self.assertIsInstance(result, NestedCompanyResponse)
+        self.assertIsInstance(result.headquarters, Address)
+        self.assertIsInstance(result.employees, list)
+        for employee in result.employees:
+            self.assertIsInstance(employee, PersonalInfo)
+            self.assertIsInstance(employee.address, Address)
+        self.assertIsInstance(result.main_products, list)
+
+    def test_async_nested_company_response(self):
+        asyncio.run(self.async_nested_company_response())
+
+
+if __name__ == "__main__":
+    unittest.main()

public_tests/test_structured_outputs.py

@@ -0,0 +1,100 @@
+import asyncio
+import unittest
+from typing import List
+
+from pydantic import BaseModel, Field
+
+from synth_ai.zyk.lms.core.main import LM
+
+
+# Define example structured output models
+class SimpleResponse(BaseModel):
+    message: str
+    confidence_between_zero_one: float = Field(
+        ..., description="Confidence level between 0 and 1"
+    )
+
+
+class ComplexResponse(BaseModel):
+    title: str
+    tags: List[str]
+    content: str
+
+
+class NestedResponse(BaseModel):
+    main_category: str
+    subcategories: List[str]
+    details: SimpleResponse
+
+
+class TestLMStructuredOutputs(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # Initialize LMs for both forced_json and stringified_json modes
+        cls.lm_forced_json = LM(
+            model_name="gpt-4o-mini",
+            formatting_model_name="gpt-4o-mini",
+            temperature=0.7,
+            max_retries="Few",
+            structured_output_mode="forced_json",
+        )
+        cls.lm_stringified_json = LM(
+            model_name="gpt-4o-mini",
+            formatting_model_name="gpt-4o-mini",
+            temperature=0.7,
+            max_retries="Few",
+            structured_output_mode="stringified_json",
+        )
+
+    def test_sync_simple_response(self):
+        for lm in [self.lm_forced_json, self.lm_stringified_json]:
+            with self.subTest(
+                mode=lm.structured_output_handler.handler.structured_output_mode
+            ):
+                result = lm.respond_sync(
+                    system_message="You are a helpful assistant.",
+                    user_message="Give me a short greeting and your confidence level.",
+                    response_model=SimpleResponse,
+                )
+                self.assertIsInstance(result, SimpleResponse)
+                self.assertIsInstance(result.message, str)
+                self.assertIsInstance(result.confidence_between_zero_one, float)
+                self.assertGreaterEqual(result.confidence_between_zero_one, 0)
+                self.assertLessEqual(result.confidence_between_zero_one, 1)
+
+    def test_sync_complex_response(self):
+        for lm in [self.lm_forced_json, self.lm_stringified_json]:
+            with self.subTest(
+                mode=lm.structured_output_handler.handler.structured_output_mode
+            ):
+                result = lm.respond_sync(
+                    system_message="You are a content creator.",
+                    user_message="Create a short blog post about AI.",
+                    response_model=ComplexResponse,
+                )
+                self.assertIsInstance(result, ComplexResponse)
+                self.assertIsInstance(result.title, str)
+                self.assertIsInstance(result.tags, list)
+                self.assertIsInstance(result.content, str)
+
+    async def async_nested_response(self, lm):
+        result = await lm.respond_async(
+            system_message="You are a categorization expert.",
+            user_message="Categorize 'Python' and provide a brief description.",
+            response_model=NestedResponse,
+        )
+        self.assertIsInstance(result, NestedResponse)
+        self.assertIsInstance(result.main_category, str)
+        self.assertIsInstance(result.subcategories, list)
+        self.assertIsInstance(result.details, SimpleResponse)
+
+    def test_async_nested_response(self):
+        for lm in [self.lm_forced_json, self.lm_stringified_json]:  #
+            with self.subTest(
+                mode=lm.structured_output_handler.handler.structured_output_mode
+            ):
+                asyncio.run(self.async_nested_response(lm))
+
+
+if __name__ == "__main__":
+    unittest.main()

synth_ai/zyk/lms/caching/constants.py

@@ -0,0 +1 @@
+DISKCACHE_SIZE_LIMIT = 10 * 1024 * 1024 * 1024 #10GB

synth_ai/zyk/lms/caching/ephemeral.py

@@ -0,0 +1,50 @@
+import os
+from dataclasses import dataclass
+from typing import Dict, Optional, Union
+
+from diskcache import Cache
+from pydantic import BaseModel
+
+from synth_ai.zyk.lms.caching.constants import DISKCACHE_SIZE_LIMIT
+
+
+@dataclass
+class EphemeralCache:
+    def __init__(self, fast_cache_dir: str = ".cache/ephemeral_cache"):
+        os.makedirs(fast_cache_dir, exist_ok=True)
+        self.fast_cache = Cache(fast_cache_dir, size_limit=DISKCACHE_SIZE_LIMIT)
+
+    def hit_cache(self, key: str, response_model: BaseModel) -> Optional[Dict]:
+        assert isinstance(response_model, BaseModel)
+        if key in self.fast_cache:
+            try:
+                cache_data = self.fast_cache[key]
+            except AttributeError:
+                return None
+            if response_model is not None:
+                if isinstance(cache_data["response"], dict):
+                    response = cache_data["response"]
+                    return response_model(**response)
+            if isinstance(cache_data, str):
+                return cache_data
+        return None
+
+    def add_to_cache(self, key: str, response: Union[BaseModel, str]) -> None:
+        if isinstance(response, BaseModel):
+            response_dict = response.model_dump()
+            response_class = response.__class__.__name__
+        elif isinstance(response, str):
+            response_dict = response
+            response_class = None
+        else:
+            raise ValueError(f"Invalid response type: {type(response)}")
+
+        cache_data = {
+            "response": response_dict,
+            "response_class": response_class,
+        }
+        self.fast_cache[key] = cache_data
+        return key
+
+    def close(self):
+        self.fast_cache.close()

synth_ai/zyk/lms/caching/handler.py

@@ -0,0 +1,92 @@
+import hashlib
+from typing import Any, Dict, List, Type, Union
+
+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.config import should_use_cache
+
+persistent_cache = PersistentCache()
+ephemeral_cache = EphemeralCache()
+
+
+def map_params_to_key(
+    messages: List[Dict],
+    model: str,
+    temperature: float,
+    response_model: Type[BaseModel],
+) -> 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 ""
+    return hashlib.sha256(
+        (
+            normalized_messages
+            + normalized_model
+            + normalized_temperature
+            + normalized_response_model
+        ).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 hit_managed_cache(
+        self, model: str, messages: List[Dict[str, Any]], lm_config: Dict[str, Any] = {}
+    ) -> str:
+        if not should_use_cache():
+            return None
+
+        assert isinstance(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),
+        )
+
+        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: Union[str, BaseModel],
+    ) -> None:
+        if not should_use_cache():
+            return
+
+        assert isinstance(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),
+        )
+        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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,55 @@
+from typing import Dict, Optional, Type, Union
+from dataclasses import dataclass
+from pydantic import BaseModel
+import json
+import sqlite3
+import os
+
+@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: Type[BaseModel]) -> Optional[Dict]:
+        self.cursor.execute("SELECT response FROM cache WHERE key = ?", (key,))
+        result = self.cursor.fetchone()
+        if not result:
+            return None
+        result = json.loads(result[0])
+        if result and response_model and "response" not in result:
+            return response_model(**result)
+        elif result and response_model:
+            return response_model(**json.loads(result["response"]))
+        elif result and not isinstance(result, dict):
+            return result
+        elif result and isinstance(result, dict) and "response" in result:
+            return result["response"]
+        return None
+
+    def add_to_cache(self, key: str, response: Union[BaseModel, str]) -> None:
+        if isinstance(response, BaseModel):
+            response_dict = response.model_dump()
+            response_class = response.__class__.__name__
+        elif isinstance(response, str):
+            response_dict = response
+            response_class = None
+        else:
+            raise ValueError(f"Invalid response type: {type(response)}")
+
+        cache_data = {
+            "response": response_dict,
+            "response_class": response_class,
+        }
+        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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,35 @@
+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
+
+
+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__()

synth_ai/zyk/lms/core/exceptions.py

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