mirascope 1.22.4__py3-none-any.whl → 2.1.1__py3-none-any.whl

mirascope/core/base/_extract_with_tools.py

@@ -1,189 +0,0 @@
-"""The `extract_with_tools_factory` method."""
-
-from collections.abc import Awaitable, Callable
-from functools import wraps
-from typing import ParamSpec, TypeVar, overload
-
-from pydantic import BaseModel
-
-from ._create import create_factory
-from ._utils import (
-    BaseType,
-    GetJsonOutput,
-    SameSyncAndAsyncClientSetupCall,
-    SetupCall,
-    extract_tool_return,
-    fn_is_async,
-)
-from ._utils._get_fields_from_call_args import get_fields_from_call_args
-from .call_params import BaseCallParams
-from .call_response import BaseCallResponse
-from .dynamic_config import BaseDynamicConfig
-from .tool import BaseTool
-
-_BaseCallResponseT = TypeVar("_BaseCallResponseT", bound=BaseCallResponse)
-_SameSyncAndAsyncClientT = TypeVar("_SameSyncAndAsyncClientT", contravariant=True)
-_SyncBaseClientT = TypeVar("_SyncBaseClientT", contravariant=True)
-_AsyncBaseClientT = TypeVar("_AsyncBaseClientT", contravariant=True)
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", bound=BaseDynamicConfig)
-_AsyncBaseDynamicConfigT = TypeVar("_AsyncBaseDynamicConfigT", bound=BaseDynamicConfig)
-_ParsedOutputT = TypeVar("_ParsedOutputT")
-_BaseCallParamsT = TypeVar("_BaseCallParamsT", bound=BaseCallParams)
-_ResponseT = TypeVar("_ResponseT")
-_ResponseChunkT = TypeVar("_ResponseChunkT")
-_AsyncResponseT = TypeVar("_AsyncResponseT")
-_AsyncResponseChunkT = TypeVar("_AsyncResponseChunkT")
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-_ResponseModelT = TypeVar("_ResponseModelT", bound=BaseModel | BaseType)
-_P = ParamSpec("_P")
-
-
-def extract_with_tools_factory(  # noqa: ANN202
-    *,
-    TCallResponse: type[_BaseCallResponseT],
-    setup_call: SameSyncAndAsyncClientSetupCall[
-        _SameSyncAndAsyncClientT,
-        _BaseDynamicConfigT,
-        _AsyncBaseDynamicConfigT,
-        _BaseCallParamsT,
-        _ResponseT,
-        _ResponseChunkT,
-        _AsyncResponseT,
-        _AsyncResponseChunkT,
-        _BaseToolT,
-    ]
-    | SetupCall[
-        _SyncBaseClientT,
-        _AsyncBaseClientT,
-        _BaseDynamicConfigT,
-        _AsyncBaseDynamicConfigT,
-        _BaseCallParamsT,
-        _ResponseT,
-        _ResponseChunkT,
-        _AsyncResponseT,
-        _AsyncResponseChunkT,
-        _BaseToolT,
-    ],
-    get_json_output: GetJsonOutput[_BaseCallResponseT],
-):
-    """Returns the wrapped function with the provider specific interfaces."""
-    create_decorator = create_factory(
-        TCallResponse=TCallResponse, setup_call=setup_call
-    )
-
-    @overload
-    def decorator(
-        fn: Callable[_P, _BaseDynamicConfigT],
-        model: str,
-        tools: list[type[BaseTool] | Callable],
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT] | None,
-        client: _SameSyncAndAsyncClientT | _SyncBaseClientT | None,
-        call_params: _BaseCallParamsT,
-    ) -> Callable[
-        _P,
-        (_ResponseModelT | _BaseCallResponseT) | (_ParsedOutputT | _BaseCallResponseT),
-    ]: ...
-
-    @overload
-    def decorator(
-        fn: Callable[_P, Awaitable[_AsyncBaseDynamicConfigT]],
-        model: str,
-        tools: list[type[BaseTool] | Callable],
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT] | None,
-        client: _SameSyncAndAsyncClientT | _AsyncBaseClientT | None,
-        call_params: _BaseCallParamsT,
-    ) -> Callable[
-        _P,
-        Awaitable[
-            (_ResponseModelT | _BaseCallResponseT)
-            | (_ParsedOutputT | _BaseCallResponseT)
-        ],
-    ]: ...
-
-    def decorator(
-        fn: Callable[_P, _BaseDynamicConfigT]
-        | Callable[_P, Awaitable[_AsyncBaseDynamicConfigT]],
-        model: str,
-        tools: list[type[BaseTool] | Callable],
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT] | None,
-        client: _SameSyncAndAsyncClientT | _SyncBaseClientT | None,
-        call_params: _BaseCallParamsT,
-    ) -> Callable[
-        _P,
-        (_ResponseModelT | _BaseCallResponseT)
-        | (_ParsedOutputT | _BaseCallResponseT)
-        | Awaitable[
-            (_ResponseModelT | _BaseCallResponseT)
-            | (_ParsedOutputT | _BaseCallResponseT)
-        ],
-    ]:
-        fn._model = model  # pyright: ignore [reportFunctionMemberAccess]
-        fn.__mirascope_call__ = True  # pyright: ignore [reportFunctionMemberAccess]
-        create_decorator_kwargs = {
-            "model": model,
-            "tools": tools,
-            "response_model": response_model,
-            "output_parser": None,
-            "json_mode": True,
-            "client": client,
-            "call_params": call_params,
-        }
-        if fn_is_async(fn):
-
-            @wraps(fn)
-            async def inner_async(*args: _P.args, **kwargs: _P.kwargs) -> (
-                _ResponseModelT | _BaseCallResponseT
-            ) | (_ParsedOutputT | _BaseCallResponseT):
-                call_response = await create_decorator(
-                    fn=fn, **create_decorator_kwargs
-                )(*args, **kwargs)
-                try:
-                    if call_response.tools:
-                        return call_response
-                    fields_from_call_args = get_fields_from_call_args(
-                        response_model, fn, args, kwargs
-                    )
-                    json_output = get_json_output(call_response, True)
-                    output = extract_tool_return(
-                        response_model, json_output, False, fields_from_call_args
-                    )
-                except Exception as e:
-                    e._response = call_response  # pyright: ignore [reportAttributeAccessIssue]
-                    raise e
-                if isinstance(output, BaseModel):
-                    output._response = call_response  # pyright: ignore [reportAttributeAccessIssue]
-                return output if not output_parser else output_parser(output)  # pyright: ignore [reportArgumentType, reportReturnType]
-
-            return inner_async
-        else:
-
-            @wraps(fn)
-            def inner(*args: _P.args, **kwargs: _P.kwargs) -> (
-                _ResponseModelT | _BaseCallResponseT
-            ) | (_ParsedOutputT | _BaseCallResponseT):
-                call_response = create_decorator(fn=fn, **create_decorator_kwargs)(
-                    *args, **kwargs
-                )
-                try:
-                    if call_response.tools:
-                        return call_response
-                    fields_from_call_args = get_fields_from_call_args(
-                        response_model, fn, args, kwargs
-                    )
-                    json_output = get_json_output(call_response, True)
-                    output = extract_tool_return(
-                        response_model, json_output, False, fields_from_call_args
-                    )
-                except Exception as e:
-                    e._response = call_response  # pyright: ignore [reportAttributeAccessIssue]
-                    raise e
-                if isinstance(output, BaseModel):
-                    output._response = call_response  # pyright: ignore [reportAttributeAccessIssue]
-                return output if not output_parser else output_parser(output)  # pyright: ignore [reportArgumentType, reportReturnType]
-
-            return inner
-
-    return decorator

mirascope/core/base/_partial.py

@@ -1,95 +0,0 @@
-"""
---------------------------------------------------------------------------------
-Source: https://github.com/pydantic/pydantic/issues/6381#issuecomment-1831607091
-By: silviumarcu
-
-This code is used in accordance with the repository's license, and this reference
-serves as an acknowledgment of the original author's contribution to this project.
---------------------------------------------------------------------------------
-"""
-
-from copy import deepcopy
-from typing import TypeVar, get_args, get_origin
-
-from pydantic import BaseModel, create_model
-from pydantic.fields import FieldInfo
-
-Model = TypeVar("Model", bound=BaseModel)
-
-
-def _process_annotation(annotation: type) -> type:
-    """Recursively process type annotations to make them optional."""
-    # Get the origin type (e.g., list from list[str])
-    origin = get_origin(annotation)
-
-    if origin is None:
-        # If it's a BaseModel, make it partial
-        if isinstance(annotation, type) and issubclass(annotation, BaseModel):
-            return partial(annotation) | None  # pyright: ignore [reportReturnType]
-        # For simple types, just make them optional
-        return annotation | None  # pyright: ignore [reportReturnType]
-
-    # Get the type arguments (e.g., str from list[str])
-    args = get_args(annotation)
-
-    # Recursively process each type argument
-    processed_args = tuple(
-        _process_annotation(arg) if isinstance(arg, type) else arg for arg in args
-    )
-
-    # Reconstruct the type with processed arguments
-    return (
-        origin[processed_args[0] if len(processed_args) == 1 else processed_args] | None
-    )  # pyright: ignore [reportReturnType]
-
-
-def partial(
-    wrapped_class: type[Model], preserve_fields: set[str] | None = None
-) -> type[Model]:
-    """Generate a new class with all attributes optionals.
-
-    This decorator will wrap a class inheriting from BaseModel and will recursively
-    convert all its attributes and its children's attributes to optionals, including
-    handling generic type hints like list[Model].
-
-    Example:
-    ```python
-    @partial
-    class User(BaseModel):
-        name: str
-        friends: list[Friend]  # Will become list[PartialFriend] | None
-
-    user = User()  # All fields optional
-    ```
-    """
-    if preserve_fields is None:
-        preserve_fields = set()
-
-    def _make_field_optional(
-        field: FieldInfo,
-    ) -> tuple[object, FieldInfo]:
-        tmp_field = deepcopy(field)
-
-        # Process the field's annotation
-        tmp_field.annotation = _process_annotation(field.annotation)  # pyright: ignore [reportArgumentType]
-
-        # Set default value
-        tmp_field.default = None
-
-        return tmp_field.annotation, tmp_field
-
-    return create_model(
-        f"Partial{wrapped_class.__name__}",
-        __base__=wrapped_class,
-        __module__=wrapped_class.__module__,
-        __doc__=wrapped_class.__doc__,
-        __config__=None,
-        __validators__=None,
-        __cls_kwargs__=None,
-        **{
-            field_name: (field_info.annotation, field_info)
-            if field_name in preserve_fields
-            else _make_field_optional(field_info)
-            for field_name, field_info in wrapped_class.model_fields.items()
-        },
-    )

mirascope/core/base/_utils/__init__.py

@@ -1,92 +0,0 @@
-"""Internal Utilities."""
-
-from ._base_message_param_converter import BaseMessageParamConverter
-from ._base_type import BaseType, is_base_type
-from ._convert_base_model_to_base_tool import convert_base_model_to_base_tool
-from ._convert_base_type_to_base_tool import convert_base_type_to_base_tool
-from ._convert_function_to_base_tool import convert_function_to_base_tool
-from ._default_tool_docstring import DEFAULT_TOOL_DOCSTRING
-from ._extract_tool_return import extract_tool_return
-from ._fn_is_async import fn_is_async
-from ._format_template import format_template
-from ._get_audio_type import get_audio_type
-from ._get_common_usage import get_common_usage
-from ._get_create_fn_or_async_create_fn import get_async_create_fn, get_create_fn
-from ._get_document_type import get_document_type
-from ._get_dynamic_configuration import get_dynamic_configuration
-from ._get_fn_args import get_fn_args
-from ._get_image_dimensions import get_image_dimensions
-from ._get_image_type import get_image_type
-from ._get_metadata import get_metadata
-from ._get_possible_user_message_param import get_possible_user_message_param
-from ._get_prompt_template import get_prompt_template
-from ._get_template_values import get_template_values
-from ._get_template_variables import get_template_variables
-from ._get_unsupported_tool_config_keys import get_unsupported_tool_config_keys
-from ._is_prompt_template import is_prompt_template
-from ._json_mode_content import json_mode_content
-from ._messages_decorator import MessagesDecorator, messages_decorator
-from ._parse_content_template import parse_content_template
-from ._parse_prompt_messages import parse_prompt_messages
-from ._pil_image_to_bytes import pil_image_to_bytes
-from ._protocols import (
-    AsyncCreateFn,
-    CalculateCost,
-    CallDecorator,
-    CreateFn,
-    GetJsonOutput,
-    HandleStream,
-    HandleStreamAsync,
-    LLMFunctionDecorator,
-    SameSyncAndAsyncClientSetupCall,
-    SetupCall,
-)
-from ._setup_call import setup_call
-from ._setup_extract_tool import setup_extract_tool
-
-__all__ = [
-    "DEFAULT_TOOL_DOCSTRING",
-    "AsyncCreateFn",
-    "BaseMessageParamConverter",
-    "BaseType",
-    "CalculateCost",
-    "CallDecorator",
-    "CreateFn",
-    "GetJsonOutput",
-    "HandleStream",
-    "HandleStreamAsync",
-    "LLMFunctionDecorator",
-    "MessagesDecorator",
-    "SameSyncAndAsyncClientSetupCall",
-    "SetupCall",
-    "convert_base_model_to_base_tool",
-    "convert_base_type_to_base_tool",
-    "convert_function_to_base_tool",
-    "extract_tool_return",
-    "fn_is_async",
-    "format_template",
-    "get_async_create_fn",
-    "get_audio_type",
-    "get_common_usage",
-    "get_create_fn",
-    "get_document_type",
-    "get_dynamic_configuration",
-    "get_fn_args",
-    "get_image_dimensions",
-    "get_image_type",
-    "get_metadata",
-    "get_possible_user_message_param",
-    "get_prompt_template",
-    "get_template_values",
-    "get_template_variables",
-    "get_unsupported_tool_config_keys",
-    "is_base_type",
-    "is_prompt_template",
-    "json_mode_content",
-    "messages_decorator",
-    "parse_content_template",
-    "parse_prompt_messages",
-    "pil_image_to_bytes",
-    "setup_call",
-    "setup_extract_tool",
-]

mirascope/core/base/_utils/_base_message_param_converter.py

@@ -1,22 +0,0 @@
-"""Contains the BaseMessageParamConverter class."""
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-from mirascope.core.base.message_param import BaseMessageParam
-
-
-class BaseMessageParamConverter(ABC):
-    """Base class for converting message params to/from provider formats."""
-
-    @staticmethod
-    @abstractmethod
-    def to_provider(message_params: list[BaseMessageParam]) -> list[Any]:
-        """Converts base message params -> provider-specific messages."""
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def from_provider(message_params: list[Any]) -> list[BaseMessageParam]:
-        """Converts provider-specific messages -> Base message params."""
-        pass

mirascope/core/base/_utils/_base_type.py

@@ -1,26 +0,0 @@
-"""This module contains utility functions for base types."""
-
-import inspect
-from enum import Enum
-from typing import (
-    Annotated,
-    Any,
-    Literal,
-    TypeAlias,
-    Union,
-    get_origin,
-)
-
-from typing_extensions import TypeIs
-
-BaseType: TypeAlias = str | int | float | bool | bytes | list | set | tuple | dict
-
-
-def is_base_type(type_: Any) -> TypeIs[type[BaseType]]:  # noqa: ANN401
-    """Check if a type is a base type."""
-    base_types = {str, int, float, bool, bytes, list, set, tuple, dict}
-    return (
-        (inspect.isclass(type_) and issubclass(type_, Enum))
-        or type_ in base_types
-        or get_origin(type_) in base_types.union({Literal, Union, Annotated})
-    )

mirascope/core/base/_utils/_convert_base_model_to_base_tool.py

@@ -1,48 +0,0 @@
-"""Utility for converting a model into a base tool."""
-
-import inspect
-from abc import update_abstractmethods
-from typing import Any, TypeVar, cast
-
-from pydantic import BaseModel, create_model
-
-from ..from_call_args import is_from_call_args
-from ._default_tool_docstring import DEFAULT_TOOL_DOCSTRING
-
-BaseToolT = TypeVar("BaseToolT", bound=BaseModel)
-
-
-def convert_base_model_to_base_tool(
-    model: type[BaseModel], base: type[BaseToolT]
-) -> type[BaseToolT]:
-    """Converts a `BaseModel` schema to a `BaseToolT` type.
-
-    By adding a docstring (if needed) and passing on fields and field information in
-    dictionary format, a Pydantic `BaseModel` can be converted into an `BaseTool` for
-    performing extraction.
-
-    Args:
-        model: The `BaseModel` schema to convert.
-        base: The base type to extend with the `BaseModel` fields.
-
-    Returns:
-        The constructed `BaseModelT` type.
-    """
-    field_definitions = {
-        field_name: (field_info.annotation, field_info)
-        for field_name, field_info in model.model_fields.items()
-        if not is_from_call_args(field_info)
-    }
-    tool_type = create_model(
-        f"{model.__name__}",
-        __base__=base,
-        __doc__=model.__doc__ if model.__doc__ else DEFAULT_TOOL_DOCSTRING,
-        **cast(dict[str, Any], field_definitions),
-    )
-    tool_type.model_config = model.model_config | tool_type.model_config
-    bases = list(tool_type.__bases__)
-    tool_type.__bases__ = tuple(bases) if model in bases else tuple([model] + bases)
-    for name, value in inspect.getmembers(model):
-        if not hasattr(tool_type, name) or name in ["_name", "_description", "call"]:
-            setattr(tool_type, name, value)
-    return update_abstractmethods(tool_type)

mirascope/core/base/_utils/_convert_base_type_to_base_tool.py

@@ -1,24 +0,0 @@
-"""This module contains the `convert_base_type_to_base_tool` function."""
-
-from typing import Annotated, TypeVar, get_args, get_origin
-
-from pydantic import BaseModel, create_model
-
-from ._base_type import BaseType
-from ._default_tool_docstring import DEFAULT_TOOL_DOCSTRING
-
-BaseToolT = TypeVar("BaseToolT", bound=BaseModel)
-
-
-def convert_base_type_to_base_tool(
-    schema: type[BaseType], base: type[BaseToolT]
-) -> type[BaseToolT]:
-    """Converts a `BaseType` to a `BaseToolT` type."""
-    if get_origin(schema) == Annotated:
-        schema.__name__ = get_args(schema)[0].__name__
-    return create_model(
-        schema.__name__,
-        __base__=base,
-        __doc__=DEFAULT_TOOL_DOCSTRING,
-        value=(schema, ...),
-    )

mirascope/core/base/_utils/_convert_function_to_base_tool.py

@@ -1,139 +0,0 @@
-import inspect
-from abc import update_abstractmethods
-from collections.abc import Callable
-from typing import Any, TypeVar, cast, get_type_hints
-
-import jiter
-from docstring_parser import Docstring, DocstringMeta, compose, parse
-from pydantic import BaseModel, create_model
-from pydantic.fields import FieldInfo
-
-from ._default_tool_docstring import DEFAULT_TOOL_DOCSTRING
-
-BaseToolT = TypeVar("BaseToolT", bound=BaseModel)
-
-
-def convert_function_to_base_tool(
-    fn: Callable,
-    base: type[BaseToolT],
-    __doc__: str | None = None,
-    __namespace__: str | None = None,
-) -> type[BaseToolT]:
-    """Constructs a `BaseToolT` type from the given function.
-
-    This method expects all function parameters to be properly documented in identical
-    order with identical variable names, as well as descriptions of each parameter.
-    Errors will be raised if any of these conditions are not met.
-
-    Args:
-        fn: The function to convert.
-        base: The `BaseToolT` type to which the function is converted.
-        __doc__: The docstring to use for the constructed `BaseToolT` type.
-        __namespace__: The namespace to use for the constructed `BaseToolT` type.
-
-    Returns:
-        The constructed `BaseToolT` type.
-
-    Raises:
-        ValueError: if the given function's parameters don't have type annotations.
-        ValueError: if a given function's parameter is in the docstring args section but
-            the name doesn't match the docstring's parameter name.
-        ValueError: if a given function's parameter is in the docstring args section but
-            doesn't have a docstring description.
-    """
-    docstring, examples = None, []
-    func_doc = __doc__ or fn.__doc__
-    if func_doc:
-        docstring = parse(func_doc)
-        for example in docstring.examples or []:
-            if example.description:
-                examples.append(jiter.from_json(example.description.encode()))
-        cleaned_docstring = Docstring(style=docstring.style)
-        cleaned_docstring.short_description = docstring.short_description
-        cleaned_docstring.blank_after_short_description = (
-            docstring.blank_after_short_description
-        )
-        cleaned_docstring.long_description = docstring.long_description
-        cleaned_docstring.blank_after_long_description = (
-            docstring.blank_after_long_description
-        )
-        cleaned_docstring.meta = cast(
-            list[DocstringMeta], docstring.many_returns + docstring.raises
-        )
-        func_doc = compose(cleaned_docstring)
-
-    field_definitions = {}
-    hints = get_type_hints(fn, include_extras=True)
-    has_self = False
-    for i, parameter in enumerate(inspect.signature(fn).parameters.values()):
-        if parameter.name == "self":
-            has_self = True
-            continue
-        if parameter.name == "cls":
-            continue
-        if parameter.annotation == inspect.Parameter.empty:
-            raise ValueError("All parameters must have a type annotation.")
-
-        docstring_description = None
-        if docstring and i < len(docstring.params):
-            docstring_param = docstring.params[i]
-            if docstring_param.arg_name != parameter.name:
-                raise ValueError(
-                    f"Function parameter name {parameter.name} does not match docstring "
-                    f"parameter name {docstring_param.arg_name}. Make sure that the "
-                    "parameter names match exactly."
-                )
-            if not docstring_param.description:
-                raise ValueError("All parameters must have a description.")
-            docstring_description = docstring_param.description
-
-        field_info = FieldInfo(annotation=hints[parameter.name])
-        if parameter.default != inspect.Parameter.empty:
-            field_info.default = parameter.default
-        if docstring_description:  # we check falsy here because this comes from docstr
-            field_info.description = docstring_description
-
-        param_name = parameter.name
-        if param_name.startswith("model_"):  # model_ is a BaseModel reserved namespace
-            param_name = "aliased_" + param_name
-            field_info.alias = parameter.name
-            field_info.validation_alias = parameter.name
-            field_info.serialization_alias = parameter.name
-
-        field_definitions[param_name] = (
-            hints[parameter.name],
-            field_info,
-        )
-
-    model = create_model(
-        f"{__namespace__}_{fn.__name__}" if __namespace__ else fn.__name__,
-        __base__=base,
-        __doc__=inspect.cleandoc(func_doc) if func_doc else DEFAULT_TOOL_DOCSTRING,
-        **cast(dict[str, Any], field_definitions),
-    )
-    if examples:
-        model.model_config["json_schema_extra"] = {"examples": examples}
-
-    def call(self: base) -> Any:  # pyright: ignore [reportInvalidTypeForm] # noqa: ANN401
-        return fn(
-            **(
-                ({"self": self} if has_self else {})
-                | {
-                    str(
-                        self.model_fields[field_name].alias
-                        if self.model_fields[field_name].alias
-                        else field_name
-                    ): getattr(self, field_name)
-                    for field_name in self.model_dump(exclude={"tool_call", "delta"})
-                }
-            )
-        )
-
-    async def call_async(self: base) -> Callable:  # pyright: ignore [reportInvalidTypeForm]
-        return await call(self)
-
-    if inspect.iscoroutinefunction(fn):
-        model.call = call_async  # pyright: ignore [reportAttributeAccessIssue]
-    else:
-        model.call = call  # pyright: ignore [reportAttributeAccessIssue]
-    return update_abstractmethods(model)