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

synth_ai/zyk/lms/vendors/openai_standard.py

@@ -0,0 +1,345 @@
+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.constants import SPECIAL_BASE_TEMPS
+
+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)
+        lm_config["reasoning_effort"] = reasoning_effort
+        cache_result = used_cache_handler.hit_managed_cache(
+            model, messages, lm_config=lm_config, tools=tools
+        )
+        if cache_result:
+            return cache_result
+
+        # Common API call params
+        api_params = {
+            "model": model,
+            "messages": messages,
+        }
+
+        # Add tools if provided
+        if tools and all(isinstance(tool, BaseTool) for tool in tools):
+            api_params["tools"] = [tool.to_openai_tool() for tool in tools]
+        elif tools:
+            api_params["tools"] = tools
+
+        # Only add temperature for non o1/o3 models
+        if not any(prefix in model for prefix in ["o1-", "o3-"]):
+            api_params["temperature"] = lm_config.get(
+                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
+            )
+
+        # Add reasoning_effort only for o3-mini
+        if model in ["o3-mini"]:
+            print("Reasoning effort:", reasoning_effort)
+            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,
+        )
+        lm_config["reasoning_effort"] = reasoning_effort
+        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,
+    #     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
+        )
+        lm_config["reasoning_effort"] = reasoning_effort
+        cache_result = used_cache_handler.hit_managed_cache(
+            model, messages, lm_config=lm_config, tools=tools
+        )
+        if cache_result:
+            return cache_result
+
+        # Common API call params
+        api_params = {
+            "model": model,
+            "messages": messages,
+        }
+
+        # Add tools if provided
+        if tools and all(isinstance(tool, BaseTool) for tool in tools):
+            api_params["tools"] = [tool.to_openai_tool() for tool in tools]
+        elif tools:
+            api_params["tools"] = tools
+
+        # Only add temperature for non o1/o3 models
+        if not any(prefix in model for prefix in ["o1-", "o3-"]):
+            api_params["temperature"] = lm_config.get(
+                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
+            )
+
+        # Add reasoning_effort only for o3-mini
+        if model in ["o3-mini"]:
+            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,
+        )
+        lm_config["reasoning_effort"] = reasoning_effort
+        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,
+        reasoning_effort: str = "high",
+        tools: Optional[List[BaseTool]] = None,
+    ) -> BaseLMResponse:
+        lm_config = {"temperature": temperature, "response_model": response_model, "reasoning_effort": reasoning_effort}
+        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
+            )
+        )
+        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 and all(isinstance(tool, BaseTool) for tool in tools):
+            api_params["tools"] = [tool.to_openai_tool() for tool in tools]
+        elif tools:
+            api_params["tools"] = tools
+
+        # Only add temperature for non o1/o3 models
+        if not any(prefix in model for prefix in ["o1-", "o3-"]):
+            api_params["temperature"] = lm_config.get(
+                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
+            )
+
+        # Add reasoning_effort only for o3-mini
+        if model in ["o3-mini"]:
+            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,
+        )
+        lm_config["reasoning_effort"] = reasoning_effort
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+        )
+        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, "reasoning_effort": reasoning_effort}
+        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
+            )
+        )
+        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 and all(isinstance(tool, BaseTool) for tool in tools):
+            api_params["tools"] = [tool.to_openai_tool() for tool in tools]
+        elif tools:
+            api_params["tools"] = tools
+
+        # Only add temperature for non o1/o3 models
+        if not any(prefix in model for prefix in ["o1-", "o3-"]):
+            api_params["temperature"] = lm_config.get(
+                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
+            )
+
+        # Add reasoning_effort only for o3-mini
+        if model in ["o3-mini"]:
+            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,
+        )
+        lm_config["reasoning_effort"] = reasoning_effort
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+        )
+        return lm_response

synth_ai/zyk/lms/vendors/retries.py

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

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

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

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

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

@@ -0,0 +1,11 @@
+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"))

{synth_ai-0.1.0.dev50.dist-info → synth_ai-0.1.0.dev52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.1.0.dev50
+Version: 0.1.0.dev52
 Summary: Software for aiding the best and multiplying the will.
 Home-page: https://github.com/synth-laboratories/synth-ai
 Author: Josh Purtell
@@ -43,6 +43,7 @@ Requires-Dist: anthropic>=0.34.2
 Requires-Dist: google>=3.0.0
 Requires-Dist: google-api-core
 Requires-Dist: google-generativeai
+Requires-Dist: google-genai
 Requires-Dist: together>=1.2.12
 Requires-Dist: langfuse>=2.56.1
 Requires-Dist: datasets>=3.2.0

synth_ai-0.1.0.dev52.dist-info/RECORD

@@ -0,0 +1,46 @@
+synth_ai/__init__.py,sha256=dflUvGJ59nrEo81cf7GqUA4ExYbjePhQShSLsr1B0qE,325
+synth_ai/zyk/__init__.py,sha256=kGMD-drlBVdsyT-QFODMwaZUtxPCJ9mg58GKQUvFqo0,134
+synth_ai/zyk/lms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/config.py,sha256=UBMi0DIFQDBV_eGPK5vG8R7VwxXcV10BPGq1iV8vVjg,282
+synth_ai/zyk/lms/constants.py,sha256=AIZZBGagbcEATK4zOBIC_jkSguSc41z-EfwHGh-xyuU,656
+synth_ai/zyk/lms/caching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/caching/constants.py,sha256=fPi3x9p-yRdvixMSIyclvmwmwCRliXLXQjEm6dRnG8s,52
+synth_ai/zyk/lms/caching/dbs.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/caching/ephemeral.py,sha256=pNMG5Rzzp2m0Ln1UYmWxz1qbXwq3iNIrhjYAS0yO3ZE,2370
+synth_ai/zyk/lms/caching/handler.py,sha256=DGBxc6Xw1KGCncI5e_lVRgLC-S7qQ5bSTJMifFTZSc4,4914
+synth_ai/zyk/lms/caching/initialize.py,sha256=zZls6RKAax6Z-8oJInGaSg_RPN_fEZ6e_RCX64lMLJw,416
+synth_ai/zyk/lms/caching/persistent.py,sha256=ZaY1A9qhvfNKzcAI9FnwbIrgMKvVeIfb_yCyl3M8dxE,2860
+synth_ai/zyk/lms/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/core/all.py,sha256=wakK0HhvYRuaQZmxClURyNf3vUkTbm3OABw3TgpMjOQ,1185
+synth_ai/zyk/lms/core/exceptions.py,sha256=K0BVdAzxVIchsvYZAaHEH1GAWBZvpxhFi-SPcJOjyPQ,205
+synth_ai/zyk/lms/core/main.py,sha256=pLz7COTdvDWQivYaA1iYYF2onUOosD_sFaPJG48bdKM,10598
+synth_ai/zyk/lms/core/vendor_clients.py,sha256=1h428pLiP6VeHvLOYRCtxfmuwJceYp30jPF5Fr48JtI,2783
+synth_ai/zyk/lms/cost/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/cost/monitor.py,sha256=cSKIvw6WdPZIRubADWxQoh1MdB40T8-jjgfNUeUHIn0,5
+synth_ai/zyk/lms/cost/statefulness.py,sha256=TOsuXL8IjtKOYJ2aJQF8TwJVqn_wQ7AIwJJmdhMye7U,36
+synth_ai/zyk/lms/structured_outputs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/structured_outputs/handler.py,sha256=TKN38zHFdVnAJoYqUgaXuUzTVFj9XBBJHx45whGjVeE,16918
+synth_ai/zyk/lms/structured_outputs/inject.py,sha256=Fy-zDeleRxOZ8ZRM6IuZ6CP2XZnMe4K2PEn4Q9c_KPY,11777
+synth_ai/zyk/lms/structured_outputs/rehabilitate.py,sha256=ecKGWrgWYUSplqHzK40KdohwaN8gBV0xl4LUReLN_vg,7910
+synth_ai/zyk/lms/tools/base.py,sha256=i-AIVRlitiQ4JMJ_BBFRSpUcWgxWIUYoHxAqfxHN_7E,4056
+synth_ai/zyk/lms/vendors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/vendors/base.py,sha256=aK4PEtkMLt_o3qD22kW-x3HJUEKdIk06zlH4kX0VkAE,760
+synth_ai/zyk/lms/vendors/openai_standard.py,sha256=dgHC7RWrxwaWto6_frKdfEKazKvvAMYJM1YgJgbVpb8,12279
+synth_ai/zyk/lms/vendors/retries.py,sha256=m-WvAiPix9ovnO2S-m53Td5VZDWBVBFuHuSK9--OVxw,38
+synth_ai/zyk/lms/vendors/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/vendors/core/anthropic_api.py,sha256=AdlKHK4jiOxb3QxS7my7EfmGCuugPljvGNN3JBkiDfQ,13689
+synth_ai/zyk/lms/vendors/core/gemini_api.py,sha256=LER31s5iQCrsHdi_Y8GFK5XBini-xwcsXt3xLUyCsJg,10947
+synth_ai/zyk/lms/vendors/core/mistral_api.py,sha256=eoEaxiMuKQEY0K4rGHA2_ZG6sBnzEm-8hBWO_JqW96M,12080
+synth_ai/zyk/lms/vendors/core/openai_api.py,sha256=O5KbRpy0pDDofVjxgZdeU69ueUl6S1DAuKykcH3gThg,6784
+synth_ai/zyk/lms/vendors/local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/vendors/local/ollama.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/vendors/supported/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/vendors/supported/deepseek.py,sha256=BElW0NGpkSA62wOqzzMtDw8XR36rSNXK5LldeHJkQrc,2430
+synth_ai/zyk/lms/vendors/supported/groq.py,sha256=Fbi7QvhdLx0F-VHO5PY-uIQlPR0bo3C9h1MvIOx8nz0,388
+synth_ai/zyk/lms/vendors/supported/ollama.py,sha256=K30VBFRTd7NYyPmyBVRZS2sm0UB651AHp9i3wd55W64,469
+synth_ai/zyk/lms/vendors/supported/together.py,sha256=Ni_jBqqGPN0PkkY-Ew64s3gNKk51k3FCpLSwlNhKbf0,342
+synth_ai-0.1.0.dev52.dist-info/licenses/LICENSE,sha256=ynhjRQUfqA_RdGRATApfFA_fBAy9cno04sLtLUqxVFM,1069
+synth_ai-0.1.0.dev52.dist-info/METADATA,sha256=A_WiPC2LlKIMWt11Ma5mQiK19q00dWePd5GQUPTcIpE,2759
+synth_ai-0.1.0.dev52.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+synth_ai-0.1.0.dev52.dist-info/top_level.txt,sha256=fBmtZyVHuKaGa29oHBaaUkrUIWTqSpoVMPiVdCDP3k8,9
+synth_ai-0.1.0.dev52.dist-info/RECORD,,

synth_ai-0.1.0.dev50.dist-info/RECORD

@@ -1,6 +0,0 @@
-synth_ai/__init__.py,sha256=6e_S1pzQpTcURfvJX9Vyd2ZBlHd98LhseeYUlFptN3s,317
-synth_ai-0.1.0.dev50.dist-info/licenses/LICENSE,sha256=ynhjRQUfqA_RdGRATApfFA_fBAy9cno04sLtLUqxVFM,1069
-synth_ai-0.1.0.dev50.dist-info/METADATA,sha256=RBepPnjBxtIJkkaBarnZ9Zx8RG6w8drL5YnsUeKRca0,2731
-synth_ai-0.1.0.dev50.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-synth_ai-0.1.0.dev50.dist-info/top_level.txt,sha256=fBmtZyVHuKaGa29oHBaaUkrUIWTqSpoVMPiVdCDP3k8,9
-synth_ai-0.1.0.dev50.dist-info/RECORD,,