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

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

@@ -0,0 +1,146 @@
+import logging
+import os
+import warnings
+from typing import Any, Dict, List, Tuple, Type
+
+import google.generativeai as genai
+from google.api_core.exceptions import ResourceExhausted
+from google.generativeai.types import HarmBlockThreshold, HarmCategory
+
+from synth_ai.zyk.lms.caching.initialize import (
+    get_cache_handler,
+)
+from synth_ai.zyk.lms.vendors.base import 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
+
+    async def _private_request_async(
+        self,
+        messages: List[Dict],
+        temperature: float = 0,
+        model_name: str = "gemini-1.5-flash",
+    ) -> str:
+        code_generation_model = genai.GenerativeModel(
+            model_name=model_name,
+            generation_config={"temperature": temperature},
+            system_instruction=messages[0]["content"],
+        )
+        result = await code_generation_model.generate_content_async(
+            messages[1]["content"],
+            safety_settings=SAFETY_SETTINGS,
+        )
+        return result.text
+
+    def _private_request_sync(
+        self,
+        messages: List[Dict],
+        temperature: float = 0,
+        model_name: str = "gemini-1.5-flash",
+    ) -> str:
+        code_generation_model = genai.GenerativeModel(
+            model_name=model_name,
+            generation_config={"temperature": temperature},
+            system_instruction=messages[0]["content"],
+        )
+        result = code_generation_model.generate_content(
+            messages[1]["content"],
+            safety_settings=SAFETY_SETTINGS,
+        )
+        return result.text
+
+    @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,
+    ) -> str:
+        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
+        )
+        if cache_result:
+            return (
+                cache_result["response"]
+                if isinstance(cache_result, dict)
+                else cache_result
+            )
+        api_result = await self._private_request_async(
+            messages,
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
+        )
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config=lm_config, output=api_result
+        )
+        return api_result
+
+    @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,
+    ) -> str:
+        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
+        )
+        if cache_result:
+            return (
+                cache_result["response"]
+                if isinstance(cache_result, dict)
+                else cache_result
+            )
+        api_result = self._private_request_sync(
+            messages,
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
+        )
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config=lm_config, output=api_result
+        )
+        return api_result

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

@@ -0,0 +1,145 @@
+import json
+from typing import Any, Dict, List, 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.vendors.constants import SPECIAL_BASE_TEMPS
+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,
+    ) -> str:
+        # "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")
+            return (
+                cache_result["response"]
+                if isinstance(cache_result, dict)
+                else cache_result
+            )
+        output = await self.async_client.beta.chat.completions.parse(
+            model=model,
+            messages=messages,
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
+            response_format=response_model,
+        )
+        # "Output", output)
+        api_result = response_model(**json.loads(output.choices[0].message.content))
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config, output=output.choices[0].message.content
+        )
+        return api_result
+
+    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,
+    ) -> str:
+        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:
+            return (
+                cache_result["response"]
+                if isinstance(cache_result, dict)
+                else cache_result
+            )
+        output = self.sync_client.beta.chat.completions.parse(
+            model=model,
+            messages=messages,
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
+            response_format=response_model,
+        )
+        api_result = response_model(**json.loads(output.choices[0].message.content))
+        used_cache_handler.add_to_managed_cache(
+            model,
+            messages,
+            lm_config=lm_config,
+            output=output.choices[0].message.content,
+        )
+        return api_result
+
+
+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

@@ -0,0 +1,141 @@
+from typing import Any, Dict, List
+
+import openai
+import pydantic_core
+
+from synth_ai.zyk.lms.caching.initialize import (
+    get_cache_handler,
+)
+from synth_ai.zyk.lms.vendors.base import VendorBase
+from synth_ai.zyk.lms.vendors.constants import SPECIAL_BASE_TEMPS
+from synth_ai.zyk.lms.vendors.retries import BACKOFF_TOLERANCE, backoff
+
+DEFAULT_EXCEPTIONS_TO_RETRY = (
+    pydantic_core._pydantic_core.ValidationError,
+    openai.APIConnectionError,
+    openai.APITimeoutError,
+)
+
+
+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,
+    ) -> str:
+        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
+        )
+        if cache_result:
+            return (
+                cache_result["response"]
+                if isinstance(cache_result, dict)
+                else cache_result
+            )
+        output = await self.async_client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
+        )
+        api_result = output.choices[0].message.content
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config=lm_config, output=api_result
+        )
+        return api_result
+
+    @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,
+    ) -> str:
+        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
+        )
+        if cache_result:
+            return (
+                cache_result["response"]
+                if isinstance(cache_result, dict)
+                else cache_result
+            )
+        output = self.sync_client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
+        )
+        api_result = output.choices[0].message.content
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config=lm_config, output=api_result
+        )
+        return api_result

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,18 @@
+import os
+
+from openai import AsyncOpenAI, OpenAI
+
+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",
+        )

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.dev4.dist-info → synth_ai-0.1.0.dev6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: synth-ai
-Version: 0.1.0.dev4
+Version: 0.1.0.dev6
 Summary: Software for aiding the best and multiplying the will.
 Author-email: Josh Purtell <josh@usesynth.ai>
 License: MIT License

synth_ai-0.1.0.dev6.dist-info/RECORD

@@ -0,0 +1,46 @@
+public_tests/synth_sdk.py,sha256=fqkzyzLb_NW4k8EiP2mJ5HZk3lDTi1juyTf9Gv_9wfc,14238
+public_tests/test_agent.py,sha256=CjPPWuMWC_TzX1DkDald-bbAxgjXE-HPQvFhq2B--5k,22363
+public_tests/test_recursive_structured_outputs.py,sha256=Ne-9XwnOxN7eSpGbNHOpegR-sRj589I84T6y8Z_4QnA,5781
+public_tests/test_structured_outputs.py,sha256=J7sfbGZ7OeB5ONIKpcCTymyayNyAdFfGokC1bcUrSx0,3651
+synth_ai/__init__.py,sha256=2siivzLbT2r-EA7m91dcJB-6Vsurc5_sX3WiKf4_o8Y,198
+synth_ai/zyk/__init__.py,sha256=zoPor1PI2OrgpCu-MBLZXcX1jAbSgD9q0kqZpTghTcQ,60
+synth_ai/zyk/lms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/config.py,sha256=CcN5NL99j0UZubyGo-MUfbPD3pWosAMju_sqgfvqLVY,201
+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=OduhhWc8TdEohli0HJkbtTxVM0egSxmOHDVfErTXTPw,1725
+synth_ai/zyk/lms/caching/handler.py,sha256=sewq5rRfqXHzCEiXvdckbuxYp9ze_EjVSndnUTsOAJY,2962
+synth_ai/zyk/lms/caching/initialize.py,sha256=zZls6RKAax6Z-8oJInGaSg_RPN_fEZ6e_RCX64lMLJw,416
+synth_ai/zyk/lms/caching/persistent.py,sha256=mQmP1z0rWVYjxwso5zIwd51Df2dWZvdHonuqsOY6SFI,2075
+synth_ai/zyk/lms/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/core/all.py,sha256=oUplKT1AsTv9Uvx2SqVjGjOsa0ml5G_GJFdKp6rPiGs,894
+synth_ai/zyk/lms/core/exceptions.py,sha256=K0BVdAzxVIchsvYZAaHEH1GAWBZvpxhFi-SPcJOjyPQ,205
+synth_ai/zyk/lms/core/main.py,sha256=LMPsr8fF93kRk5sts5Q9-acKyLsX4tmJEoifj7DQHvo,8786
+synth_ai/zyk/lms/core/vendor_clients.py,sha256=O2KWCFJ0XHWhd4-_UE-T0WQKKgz_SNT7X4nV9j1YEPM,1878
+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=2TixVuVs2w3Q3VB8n2DvNtJcJvUmQzAR1WfXn3FaX7M,13804
+synth_ai/zyk/lms/structured_outputs/inject.py,sha256=U3I4-f-9RFn5Pc6wOxqBtJCUOcf_qI5MJGzpxcjhnGI,6732
+synth_ai/zyk/lms/structured_outputs/rehabilitate.py,sha256=_QOfnI1rJxIE9-zUMhC0PedCOr6y5m6WuGScDb5gcUo,7787
+synth_ai/zyk/lms/vendors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/vendors/base.py,sha256=bs27mNfrCjQ5NsmxWnKfxZmpoAa9mTNAFr9AnGVwqLk,552
+synth_ai/zyk/lms/vendors/constants.py,sha256=zqCOyXZqo297wboR9EKVSkvpq6JCMSJyeso8HdZPKa4,102
+synth_ai/zyk/lms/vendors/openai_standard.py,sha256=nTBrI7grru1RjWHluguVU24xt__apXrOnWaq61S71nA,4796
+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=fcb0uVlInADl50MNYMT-IimM9mzO19D8_mSg9Gqp92Q,6986
+synth_ai/zyk/lms/vendors/core/gemini_api.py,sha256=vHwsIv6n1KxzxPtx10yxZcsVDr8j9ZUx8dPE9zNLWjM,5141
+synth_ai/zyk/lms/vendors/core/openai_api.py,sha256=bpS7NcOJugF6rVOxsw3FMV30hhPQVkvZ0uV-MppisyE,4967
+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=diFfdhPMO5bLFZxnYj7VT0v6jKTlOYESBkspUuVa2eY,529
+synth_ai/zyk/lms/vendors/supported/together.py,sha256=Ni_jBqqGPN0PkkY-Ew64s3gNKk51k3FCpLSwlNhKbf0,342
+synth_ai-0.1.0.dev6.dist-info/LICENSE,sha256=ynhjRQUfqA_RdGRATApfFA_fBAy9cno04sLtLUqxVFM,1069
+synth_ai-0.1.0.dev6.dist-info/METADATA,sha256=A4nzNGkU2zdFNpRiu0KruOeZHI4h0XXjAErI5WBA-Kc,2491
+synth_ai-0.1.0.dev6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+synth_ai-0.1.0.dev6.dist-info/top_level.txt,sha256=MKoWqlbnW0ZKcm_eLzeCpgAihgL59ZrZZ8Q1HnZwHdg,22
+synth_ai-0.1.0.dev6.dist-info/RECORD,,

synth_ai-0.1.0.dev6.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+public_tests
+synth_ai

synth_ai-0.1.0.dev4.dist-info/RECORD

@@ -1,7 +0,0 @@
-synth_ai/__init__.py,sha256=2siivzLbT2r-EA7m91dcJB-6Vsurc5_sX3WiKf4_o8Y,198
-synth_ai/zyk/__init__.py,sha256=zoPor1PI2OrgpCu-MBLZXcX1jAbSgD9q0kqZpTghTcQ,60
-synth_ai-0.1.0.dev4.dist-info/LICENSE,sha256=ynhjRQUfqA_RdGRATApfFA_fBAy9cno04sLtLUqxVFM,1069
-synth_ai-0.1.0.dev4.dist-info/METADATA,sha256=IOYF_pOhAYtMDK1ClxHlfpx8WCk5HgjkVkorEGfSE4g,2491
-synth_ai-0.1.0.dev4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-synth_ai-0.1.0.dev4.dist-info/top_level.txt,sha256=fBmtZyVHuKaGa29oHBaaUkrUIWTqSpoVMPiVdCDP3k8,9
-synth_ai-0.1.0.dev4.dist-info/RECORD,,

synth_ai-0.1.0.dev4.dist-info/top_level.txt

@@ -1 +0,0 @@
-synth_ai