synth-ai 0.0.0.dev3__py3-none-any.whl → 0.1.0.dev6__py3-none-any.whl

synth_ai/zyk/lms/structured_outputs/inject.py

@@ -0,0 +1,185 @@
+import json
+from typing import Any, Dict, List, Optional, Tuple, Type, get_type_hints, get_args, get_origin, Union
+from pydantic import BaseModel
+import warnings
+
+
+def generate_type_map() -> Dict[Any, str]:
+    base_types = {
+        int: "int",
+        float: "float",
+        bool: "bool",
+        str: "str",
+        Any: "Any",
+    }
+
+    collection_types = {
+        List: "List",
+        Dict: "Dict",
+        Optional: "Optional",
+    }
+
+    type_map = {}
+    for base_type, name in base_types.items():
+        type_map[base_type] = name
+        for collection, collection_name in collection_types.items():
+            if collection is Optional:
+                type_map[Optional[base_type]] = name
+            elif collection is Dict:
+                # Handle generic Dict type
+                type_map[Dict] = "Dict[Any,Any]"
+                # Provide both key and value types for Dict
+                type_map[Dict[base_type, base_type]] = f"{collection_name}[{name},{name}]"
+                # Handle Dict[Any, Any] explicitly
+                type_map[Dict[Any, Any]] = "Dict[Any,Any]"
+            else:
+                type_map[collection[base_type]] = f"{collection_name}[{name}]"
+    return type_map
+
+def generate_example_dict() -> Dict[str, Any]:
+    example_values = {
+        "str": "<Your type-str response here>",
+        "int": "<Your type-int response here>",
+        "float": "<Your type-float response here>",
+        "bool": "<Your type-bool response here>",
+        "Any": "<Your response here (infer the type from context)>",
+    }
+
+    example_dict = {}
+    for key, value in example_values.items():
+        example_dict[key] = value
+        example_dict[f"List[{key}]"] = [value]
+        example_dict[f"List[List[{key}]]"] = [[value]]
+        if key == "Dict[str,str]":
+            example_dict[f"Dict[str,{key.split('[')[1]}"] = {value: value}
+        elif key.startswith("Dict"):
+            example_dict[key] = {value: value}
+    
+    # Add example for Dict[Any,Any]
+    example_dict["Dict[Any,Any]"] = {"<key>": "<value>"}
+    
+    return example_dict
+
+base_type_examples = {
+    int: ("int", 42),
+    float: ("float", 3.14),
+    bool: ("bool", True),
+    str: ("str", "example"),
+    Any: ("Any", "<Any value>"),
+}
+
+def get_type_string(type_hint):
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
+
+    if origin is None:
+        if isinstance(type_hint, type) and issubclass(type_hint, BaseModel):
+            return type_hint.__name__
+        else:
+            return base_type_examples.get(type_hint, ("Unknown", "unknown"))[0]
+    elif origin in (list, List):
+        elem_type = get_type_string(args[0])
+        return f"List[{elem_type}]"
+    elif origin in (dict, Dict):
+        key_type = get_type_string(args[0])
+        value_type = get_type_string(args[1])
+        return f"Dict[{key_type}, {value_type}]"
+    elif origin is Union:
+        non_none_types = [t for t in args if t is not type(None)]
+        if len(non_none_types) == 1:
+            return f"Optional[{get_type_string(non_none_types[0])}]"
+        else:
+            union_types = ", ".join(get_type_string(t) for t in non_none_types)
+            return f"Union[{union_types}]"
+    else:
+        return "Any"
+
+def get_example_value(type_hint):
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
+    
+    if origin is None:
+        if isinstance(type_hint, type) and issubclass(type_hint, BaseModel):
+            example = {}
+            for field_name, field_info in type_hint.model_fields.items():
+                # Updated attribute from type_ to annotation
+                example[field_name] = get_example_value(field_info.annotation)
+            return example
+        else:
+            return base_type_examples.get(type_hint, ("Unknown", "unknown"))[1]
+    elif origin in (list, List):
+        return [get_example_value(args[0])]
+    elif origin in (dict, Dict):
+        if not args or len(args) < 2:
+            warnings.warn(
+                f"Dictionary type hint {type_hint} missing type arguments. "
+                "Defaulting to Dict[str, Any].",
+                UserWarning
+            )
+            return {"example_key": "<Any value>"}  # Default for Dict[str, Any]
+        return {get_example_value(args[0]): get_example_value(args[1])}
+    elif origin is Union:
+        non_none_types = [t for t in args if t is not type(None)]
+        return get_example_value(non_none_types[0])
+    else:
+        return "<Unknown>"
+
+def add_json_instructions_to_messages(
+    system_message,
+    user_message,
+    response_model: Optional[Type[BaseModel]] = None,
+    previously_failed_error_messages: List[str] = [],
+) -> Tuple[str, str]:
+    if response_model:
+        type_hints = get_type_hints(response_model)
+        stringified_fields = {}
+        for key, type_hint in type_hints.items():
+            example_value = get_example_value(type_hint)
+            field = response_model.model_fields[key]  # Updated for Pydantic v2
+            
+            # Adjusted for Pydantic v2
+            field_description = field.description if hasattr(field, 'description') else None
+            
+            if field_description:
+                stringified_fields[key] = (example_value, field_description)
+            else:
+                stringified_fields[key] = example_value
+        example_json = json.dumps(
+            {k: v[0] if isinstance(v, tuple) else v for k, v in stringified_fields.items()},
+            indent=4
+        )
+        description_comments = "\n".join(
+            f'// {k}: {v[1]}' for k, v in stringified_fields.items() if isinstance(v, tuple)
+        )
+        system_message += f"""\n\n
+Please deliver your response in the following JSON format:
+```json
+{example_json}
+```
+{description_comments}
+"""
+    if len(previously_failed_error_messages) != 0:
+        system_message += f"""\n\n
+Please take special care to follow the format exactly.
+Keep in mind the following:
+- Always use double quotes for strings
+
+Here are some error traces from previous attempts:
+{previously_failed_error_messages}
+"""
+    return system_message, user_message
+
+
+def inject_structured_output_instructions(
+    messages: List[Dict[str, str]],
+    response_model: Optional[Type[BaseModel]] = None,
+    previously_failed_error_messages: List[str] = [],
+) -> List[Dict[str, str]]:
+    prev_system_message_content = messages[0]["content"]
+    prev_user_message_content = messages[1]["content"]
+    system_message, user_message = add_json_instructions_to_messages(
+        prev_system_message_content, prev_user_message_content, response_model, previously_failed_error_messages
+    )
+    messages[0]["content"] = system_message
+    messages[1]["content"] = user_message
+    return messages

synth_ai/zyk/lms/structured_outputs/rehabilitate.py

@@ -0,0 +1,186 @@
+import ast
+import json
+import logging
+import re
+from typing import Dict, List, Type, Union
+
+from pydantic import BaseModel
+
+from synth_ai.zyk.lms.vendors.base import VendorBase
+from synth_ai.zyk.lms.vendors.core.openai_api import OpenAIStructuredOutputClient
+
+
+def pull_out_structured_output(
+    response_raw: str, response_model: Type[BaseModel]
+) -> BaseModel:
+    logger = logging.getLogger(__name__)
+    logger.debug(f"Raw response received: {response_raw}")
+
+    assert isinstance(
+        response_raw, str
+    ), f"Response raw is not a string: {type(response_raw)}"
+
+    # Use regex to extract JSON content within ```json ... ```
+    json_pattern = re.compile(r"```json\s*(\{.*\})\s*```", re.DOTALL)
+    match = json_pattern.search(response_raw)
+    if match:
+        response_prepared = match.group(1).strip()
+    else:
+        # Fallback to existing parsing if no code fencing is found
+        if "```" in response_raw:
+            response_prepared = response_raw.split("```")[1].strip()
+        else:
+            response_prepared = response_raw.strip()
+
+    # Replace "null" with '"None"' if needed (ensure this aligns with your data)
+    response_prepared = response_prepared.replace("null", '"None"')
+
+    logger.debug(f"Prepared response for JSON parsing: {response_prepared}")
+
+    try:
+        response = json.loads(response_prepared)
+        final = response_model(**response)
+    except json.JSONDecodeError as e:
+        # Attempt to parse using ast.literal_eval as a fallback
+        response_prepared = response_prepared.replace("\n", "").replace("\\n", "")
+        response_prepared = response_prepared.replace('\\"', '"')
+        try:
+            response = ast.literal_eval(response_prepared)
+            final = response_model(**response)
+        except Exception as inner_e:
+            raise ValueError(
+                f"Failed to parse response as {response_model}: {inner_e} - {response_prepared}"
+            )
+    except Exception as e:
+        raise ValueError(
+            f"Failed to parse response as {response_model}: {e} - {response_prepared}"
+        )
+    return final
+
+
+def fix_errant_stringified_json_sync(
+    response_raw: str,
+    response_model: Type[BaseModel],
+    models: List[str] = ["gpt-4o-mini", "gpt-4o"],
+) -> BaseModel:
+    try:
+        return pull_out_structured_output(response_raw, response_model)
+    except ValueError as e:
+        # print("")
+        mini_client = OpenAIStructuredOutputClient()
+        messages = [
+            {
+                "role": "system",
+                "content": "An AI attempted to generate stringified json that could be extracted into the provided Pydantic model. This json cannot be extracted, and an error message is provided to elucidate why. Please review the information and return a corrected response. Do not materially change the content of the response, just formatting where necessary.",
+            },
+            {
+                "role": "user",
+                "content": f"# Errant Attempt\n{response_raw}\n# Response Model\n {response_model.model_json_schema()}\n# Error Message\n {str(e)}.",
+            },
+        ]
+        for model in models:
+            if model == "gpt-4o":
+                print(
+                    "Warning - using gpt-4o for structured output correction - this could add up over time (latency, cost)"
+                )
+            try:
+                fixed_response = mini_client._hit_api_sync(
+                    model, messages=messages, lm_config={"temperature": 0.0}
+                )
+                return pull_out_structured_output(fixed_response, response_model)
+            except Exception as e:
+                pass
+        raise ValueError("Failed to fix response using any model")
+
+
+async def fix_errant_stringified_json_async(
+    response_raw: str,
+    response_model: Type[BaseModel],
+    models: List[str] = ["gpt-4o-mini", "gpt-4o"],
+) -> BaseModel:
+    try:
+        return pull_out_structured_output(response_raw, response_model)
+    except ValueError as e:
+        mini_client = OpenAIStructuredOutputClient()
+        messages = [
+            {
+                "role": "system",
+                "content": "An AI attempted to generate stringified json that could be extracted into the provided Pydantic model. This json cannot be extracted, and an error message is provided to elucidate why. Please review the information and return a corrected response. Do not materially change the content of the response, just formatting where necessary.",
+            },
+            {
+                "role": "user",
+                "content": f"# Errant Attempt\n{response_raw}\n# Response Model\n {response_model.model_json_schema()}\n# Error Message\n {str(e)}.",
+            },
+        ]
+        for model in models:
+            if model == "gpt-4o":
+                print(
+                    "Warning - using gpt-4o for structured output correction - this could add up over time (latency, cost)"
+                )
+            try:
+                fixed_response = await mini_client._hit_api_async(
+                    model, messages=messages, lm_config={"temperature": 0.0}
+                )
+                return pull_out_structured_output(fixed_response, response_model)
+            except Exception as e:
+                pass
+        raise ValueError("Failed to fix response using any model")
+
+
+async def fix_errant_forced_async(
+    messages: List[Dict],
+    response_raw: str,
+    response_model: Type[BaseModel],
+    model: str,
+) -> BaseModel:
+    try:
+        return pull_out_structured_output(response_raw, response_model)
+    except ValueError as e:
+        client = OpenAIStructuredOutputClient()
+        messages = [
+            {
+                "role": "system",
+                "content": "An AI attempted to generate stringified json that could be extracted into the provided Pydantic model. This json cannot be extracted, and an error message is provided to elucidate why. Please review the information and return a corrected response. Do not materially change the content of the response, just formatting where necessary.",
+            },
+            {
+                "role": "user",
+                "content": f"<previous messages>\n<system_message>{messages[0]['content']}</system_message>\n<user_message>{messages[1]['content']}</user_message></previous messages> # Errant Attempt\n{response_raw}\n# Response Model\n {response_model.model_json_schema()}\n# Error Message\n {str(e)}.",
+            },
+        ]
+        # print("Broken response:")
+        # print(response_raw)
+        fixed_response = await client._hit_api_async_structured_output(
+            model=model,
+            messages=messages,
+            response_model=response_model,
+            temperature=0.0,
+        )
+        # print("Fixed response:")
+        # print(fixed_response)
+        return fixed_response
+
+
+def fix_errant_forced_sync(
+    response_raw: str,
+    response_model: Type[BaseModel],
+    model: str,
+) -> BaseModel:
+    client = OpenAIStructuredOutputClient()
+    messages = [
+        {
+            "role": "system",
+            "content": "An AI attempted to generate a response that could be extracted into the provided Pydantic model. This response cannot be extracted. Please review the information and return a corrected response.",
+        },
+        {
+            "role": "user",
+            "content": f"# Errant Attempt\n{response_raw}\n# Response Model\n {response_model.model_json_schema()}",
+        },
+    ]
+    # print("Broken response:")
+    # print(response_raw)
+    fixed_response = client._hit_api_sync_structured_output(
+        model=model, messages=messages, response_model=response_model, temperature=0.0
+    )
+    # print("Fixed response:")
+    # print(fixed_response)
+    return fixed_response

synth_ai/zyk/lms/vendors/base.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+
+class VendorBase(ABC):
+    used_for_structured_outputs: bool = False
+    exceptions_to_retry: List[Exception] = []
+    
+    @abstractmethod
+    async def _hit_api_async(self, messages: List[Dict[str, Any]], response_model_override: Optional[BaseModel] = None) -> str:
+        pass
+    
+    @abstractmethod
+    def _hit_api_sync(self, messages: List[Dict[str, Any]], response_model_override: Optional[BaseModel] = None) -> str:
+        pass

synth_ai/zyk/lms/vendors/constants.py

@@ -0,0 +1,5 @@
+SPECIAL_BASE_TEMPS = {
+    "claude-3-5-sonnet-20240620": 0.7,
+    "o1-mini": 1,
+    "o1-preview": 1,
+}

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

@@ -0,0 +1,191 @@
+import json
+from typing import Any, Dict, List, Tuple, Type
+
+import anthropic
+import pydantic
+from pydantic import BaseModel
+
+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.core.openai_api import OpenAIStructuredOutputClient
+from synth_ai.zyk.lms.vendors.retries import BACKOFF_TOLERANCE, backoff
+
+ANTHROPIC_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (anthropic.APIError,)
+
+
+class AnthropicAPI(VendorBase):
+    used_for_structured_outputs: bool = True
+    exceptions_to_retry: Tuple = ANTHROPIC_EXCEPTIONS_TO_RETRY
+    sync_client: Any
+    async_client: Any
+
+    def __init__(
+        self,
+        exceptions_to_retry: Tuple[
+            Type[Exception], ...
+        ] = ANTHROPIC_EXCEPTIONS_TO_RETRY,
+        used_for_structured_outputs: bool = False,
+    ):
+        self.sync_client = anthropic.Anthropic()
+        self.async_client = anthropic.AsyncAnthropic()
+        self.used_for_structured_outputs = used_for_structured_outputs
+        self.exceptions_to_retry = exceptions_to_retry
+        self._openai_fallback = None
+
+    @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
+            )
+        response = await self.async_client.messages.create(
+            system=messages[0]["content"],
+            messages=messages[1:],
+            model=model,
+            max_tokens=lm_config.get("max_tokens", 4096),
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
+        )
+        api_result = response.content[0].text
+        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=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
+            )
+        # print("Calling Anthropic API")
+        # import time
+        # t = time.time()
+        response = self.sync_client.messages.create(
+            system=messages[0]["content"],
+            messages=messages[1:],
+            model=model,
+            max_tokens=lm_config.get("max_tokens", 4096),
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
+        )
+        # print("Time taken for API call", time.time() - t)
+        api_result = response.content[0].text
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config=lm_config, output=api_result
+        )
+        return api_result
+
+    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:
+        try:
+            # First try with Anthropic
+            response = await self.async_client.messages.create(
+                system=messages[0]["content"],
+                messages=messages[1:],
+                model=model,
+                max_tokens=4096,
+                temperature=temperature,
+            )
+            result = response.content[0].text
+            # Try to parse the result as JSON
+            parsed = json.loads(result)
+            return response_model(**parsed)
+        except (json.JSONDecodeError, pydantic.ValidationError):
+            # If Anthropic fails, fallback to OpenAI
+            if self._openai_fallback is None:
+                self._openai_fallback = OpenAIStructuredOutputClient()
+            return await self._openai_fallback._hit_api_async_structured_output(
+                model="gpt-4o",  # Fallback to GPT-4
+                messages=messages,
+                response_model=response_model,
+                temperature=temperature,
+                use_ephemeral_cache_only=use_ephemeral_cache_only,
+            )
+
+    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:
+        try:
+            # First try with Anthropic
+            import time
+
+            # t = time.time()
+            response = self.sync_client.messages.create(
+                system=messages[0]["content"],
+                messages=messages[1:],
+                model=model,
+                max_tokens=4096,
+                temperature=temperature,
+            )
+            # print("Time taken for API call", time.time() - t)
+            result = response.content[0].text
+            # Try to parse the result as JSON
+            parsed = json.loads(result)
+            return response_model(**parsed)
+        except (json.JSONDecodeError, pydantic.ValidationError):
+            # If Anthropic fails, fallback to OpenAI
+            print("WARNING - Falling back to OpenAI - THIS IS SLOW")
+            if self._openai_fallback is None:
+                self._openai_fallback = OpenAIStructuredOutputClient()
+            return self._openai_fallback._hit_api_sync_structured_output(
+                model="gpt-4o",  # Fallback to GPT-4
+                messages=messages,
+                response_model=response_model,
+                temperature=temperature,
+                use_ephemeral_cache_only=use_ephemeral_cache_only,
+            )