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

mirascope/core/base/_utils/_parse_content_template.py

@@ -1,157 +0,0 @@
-"""This module provides a function to parse content parts from a prompt template."""
-
-import re
-import urllib.request
-from typing import Any, Literal, cast
-
-from typing_extensions import TypedDict
-
-from ..message_param import (
-    AudioPart,
-    BaseMessageParam,
-    ImagePart,
-    TextPart,
-)
-from ._format_template import format_template
-from ._get_audio_type import get_audio_type
-from ._get_image_type import get_image_type
-
-_PartType = Literal["text", "image", "images", "audio", "audios"]
-
-
-class _Part(TypedDict):
-    template: str
-    type: _PartType
-    options: dict[str, str] | None
-
-
-def _parse_parts(template: str) -> list[_Part]:
-    # \{ and \} match the literal curly braces.
-    #
-    # ([^:{}]+) captures one or more characters that are not { or } or :.
-    # This captures the content before the colon.
-    #
-    # : matches the literal colon separating the type from the content.
-    #
-    # (image|images|audio|audios) captures the supported special type after the colon.
-    #
-    # (?:\(([^)]*)\))? captures the optional additional options in parentheses.
-    pattern = r"\{([^:{}]+):(image|images|audio|audios)(?:\(([^)]*)\))?\}"
-    split = re.split(pattern, template)
-    parts: list[_Part] = []
-    for i in range(0, len(split), 4):
-        if split[i]:
-            parts.append(_Part(template=split[i], type="text", options=None))
-        if i + 3 < len(split):
-            special_content = split[i + 1]
-            special_type = cast(_PartType, split[i + 2])
-            special_options = split[i + 3]
-            if special_options is not None:
-                options: dict[str, str] = {}
-                for option in special_options.split(","):
-                    key, value = option.split("=")
-                    options[key] = value
-                special_options = options
-            parts.append(
-                _Part(
-                    template=special_content, type=special_type, options=special_options
-                )
-            )
-    return parts
-
-
-def _load_media(source: str | bytes) -> bytes:
-    try:
-        # Some typing weirdness here where checking `isinstance(source, bytes)` results
-        # in a type hint of `str | bytearray | memoryview` for source in the else.
-        if isinstance(source, bytes | bytearray | memoryview):
-            data = source
-        elif source.startswith(("http://", "https://")):
-            with urllib.request.urlopen(source) as response:
-                data = response.read()
-        else:
-            with open(source, "rb") as f:
-                data = f.read()
-        return data
-    except Exception as e:  # pragma: no cover
-        raise ValueError(
-            f"Failed to load or encode data from {source}"
-        ) from e  # pragma: no cover
-
-
-def _construct_image_part(
-    source: str | bytes, options: dict[str, str] | None
-) -> ImagePart:
-    image = _load_media(source)
-    detail = None
-    if options:
-        detail = options.get("detail", None)
-    return ImagePart(
-        type="image",
-        media_type=f"image/{get_image_type(image)}",
-        image=image,
-        detail=detail,
-    )
-
-
-def _construct_audio_part(source: str | bytes) -> AudioPart:
-    # Note: audio does not currently support additional options, at least for now.
-    audio = _load_media(source)
-    return AudioPart(
-        type="audio", media_type=f"audio/{get_audio_type(audio)}", audio=audio
-    )
-
-
-def _construct_parts(
-    part: _Part, attrs: dict[str, Any]
-) -> list[TextPart] | list[ImagePart] | list[AudioPart]:
-    if part["type"] == "image":
-        source = attrs[part["template"]]
-        return [_construct_image_part(source, part["options"])] if source else []
-    elif part["type"] == "images":
-        sources = attrs[part["template"]]
-        if not isinstance(sources, list):
-            raise ValueError(
-                f"When using 'images' template, '{part['template']}' must be a list."
-            )
-        return (
-            [_construct_image_part(source, part["options"]) for source in sources]
-            if sources
-            else []
-        )
-    elif part["type"] == "audio":
-        source = attrs[part["template"]]
-        return [_construct_audio_part(source)] if source else []
-    elif part["type"] == "audios":
-        sources = attrs[part["template"]]
-        if not isinstance(sources, list):
-            raise ValueError(
-                f"When using 'audios' template, '{part['template']}' must be a list."
-            )
-        return [_construct_audio_part(source) for source in sources] if sources else []
-    else:  # text type
-        formatted_template = format_template(part["template"].strip(), attrs)
-        if not formatted_template:
-            return []
-        return [TextPart(type="text", text=formatted_template)]
-
-
-def parse_content_template(
-    role: str, template: str, attrs: dict[str, Any]
-) -> BaseMessageParam | None:
-    """Returns the content template parsed and formatted as a message parameter."""
-    if not template:
-        return None
-
-    parts = [
-        item
-        for part in _parse_parts(template)
-        for item in _construct_parts(part, attrs)
-    ]
-
-    if not parts:
-        return None
-
-    if len(parts) == 1 and parts[0].type == "text":
-        return BaseMessageParam(role=role, content=parts[0].text)
-    return BaseMessageParam(role=role, content=parts)

mirascope/core/base/_utils/_parse_prompt_messages.py

@@ -1,51 +0,0 @@
-"""This module provides a function to parse messages from a prompt template."""
-
-import re
-from typing import Any, TypeVar
-
-from pydantic import BaseModel
-
-from ..message_param import BaseMessageParam
-from ._get_template_variables import get_template_variables
-from ._parse_content_template import parse_content_template
-
-BaseToolT = TypeVar("BaseToolT", bound=BaseModel)
-
-
-def parse_prompt_messages(
-    roles: list[str], template: str, attrs: dict[str, Any]
-) -> list[BaseMessageParam]:
-    """Returns messages parsed from the provided prompt `template`.
-
-    Raises:
-        ValueError: if `MESSAGES` keyword is used with a non-list attribute.
-    """
-    messages = []
-    re_roles = "|".join([role.upper() for role in roles] + ["MESSAGES"])
-    for match in re.finditer(rf"({re_roles}):((.|\n)+?)(?=({re_roles}):|\Z)", template):
-        role, content_template = match.group(1).lower(), match.group(2).strip()
-        if role == "messages":
-            template_variables = get_template_variables(content_template, False)
-            if template_variables[0].startswith("self"):
-                if "self" not in attrs:
-                    raise ValueError(
-                        "MESSAGES keyword used with `self.` but `self` was not found."
-                    )
-                attr = getattr(attrs["self"], template_variables[0][5:])
-            else:
-                attr = attrs[template_variables[0]]
-            if attr is None or not isinstance(attr, list):
-                raise ValueError(
-                    f"MESSAGES keyword used with attribute `{template_variables[0]}`"
-                    ", which is not a `list` of messages."
-                )
-            messages += attr
-        else:
-            content = parse_content_template(role, content_template, attrs)
-            if content:
-                messages.append(content)
-    if len(messages) == 0:
-        content = parse_content_template("user", template, attrs)
-        if content:
-            messages.append(content)
-    return messages

mirascope/core/base/_utils/_protocols.py

@@ -1,215 +0,0 @@
-"""Protocols for reusable type hints."""
-
-import inspect
-from collections.abc import AsyncGenerator, Awaitable, Callable, Generator
-from typing import (
-    Any,
-    Literal,
-    ParamSpec,
-    Protocol,
-    TypeGuard,
-    TypeVar,
-    overload,
-)
-
-from ..call_response_chunk import BaseCallResponseChunk
-from ..tool import BaseTool
-
-_BaseCallResponseChunkT = TypeVar(
-    "_BaseCallResponseChunkT", covariant=True, bound=BaseCallResponseChunk
-)
-_BaseClientT = TypeVar("_BaseClientT", contravariant=True)
-_BaseCallParamsT = TypeVar("_BaseCallParamsT", contravariant=True)
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", contravariant=True)
-_ResponseT = TypeVar("_ResponseT", covariant=True)
-_AsyncResponseT = TypeVar("_AsyncResponseT", covariant=True)
-_ResponseChunkT = TypeVar("_ResponseChunkT", covariant=True)
-_InvariantResponseChunkT = TypeVar("_InvariantResponseChunkT", contravariant=True)
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-_P = ParamSpec("_P")
-_R = TypeVar("_R", contravariant=True)
-
-
-class LLMFunctionDecorator(Protocol[_BaseDynamicConfigT, _ResponseT, _AsyncResponseT]):
-    @overload
-    def __call__(
-        self, fn: Callable[_P, _BaseDynamicConfigT]
-    ) -> Callable[_P, _ResponseT]: ...
-
-    @overload
-    def __call__(
-        self, fn: Callable[_P, Awaitable[_BaseDynamicConfigT]]
-    ) -> Callable[_P, Awaitable[_AsyncResponseT]]: ...
-
-    def __call__(
-        self, fn: Callable[_P, _BaseDynamicConfigT | Awaitable[_BaseDynamicConfigT]]
-    ) -> Callable[_P, _ResponseT | Awaitable[_AsyncResponseT]]: ...  # pragma: no cover
-
-
-class AsyncCreateFn(Protocol[_ResponseT, _ResponseChunkT]):
-    @overload
-    def __call__(
-        self,
-        *,
-        stream: Literal[False] = False,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> Awaitable[_ResponseT]: ...
-
-    @overload
-    def __call__(
-        self,
-        *,
-        stream: Literal[True] = True,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> Awaitable[AsyncGenerator[_ResponseChunkT, None]]: ...
-
-    def __call__(
-        self, *, stream: bool = False, **kwargs: Any
-    ) -> Awaitable[
-        _ResponseT | AsyncGenerator[_ResponseChunkT, None]
-    ]: ...  # pragma: no cover
-
-
-class CreateFn(Protocol[_ResponseT, _ResponseChunkT]):
-    @overload
-    def __call__(
-        self,
-        *,
-        stream: Literal[False] = False,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> _ResponseT: ...
-
-    @overload
-    def __call__(
-        self,
-        *,
-        stream: Literal[True] = True,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> Generator[_ResponseChunkT, None, None]: ...
-
-    def __call__(
-        self, *, stream: bool = False, **kwargs: Any
-    ) -> _ResponseT | Generator[_ResponseChunkT, None, None]: ...
-
-
-class SetupCall(
-    Protocol[
-        _BaseClientT,
-        _BaseDynamicConfigT,
-        _BaseCallParamsT,
-        _ResponseT,
-        _ResponseChunkT,
-        _BaseToolT,
-    ]
-):
-    @overload
-    def __call__(
-        self,
-        *,
-        model: str,
-        client: _BaseClientT | None,
-        fn: Callable[..., _BaseDynamicConfigT],
-        fn_args: dict[str, Any],
-        dynamic_config: _BaseDynamicConfigT,
-        tools: list[type[BaseTool] | Callable] | None,
-        json_mode: bool,
-        call_params: _BaseCallParamsT,
-        extract: bool,
-    ) -> tuple[
-        CreateFn[_ResponseT, _ResponseChunkT],
-        str,
-        list[dict[str, Any]],
-        list[type[_BaseToolT]] | None,
-        dict[str, Any],
-    ]: ...
-
-    @overload
-    def __call__(
-        self,
-        *,
-        model: str,
-        client: _BaseClientT | None,
-        fn: Callable[_P, Awaitable[_BaseDynamicConfigT]],
-        fn_args: dict[str, Any],
-        dynamic_config: _BaseDynamicConfigT,
-        tools: list[type[BaseTool] | Callable] | None,
-        json_mode: bool,
-        call_params: _BaseCallParamsT,
-        extract: bool,
-    ) -> tuple[
-        AsyncCreateFn[_ResponseT, _ResponseChunkT],
-        str,
-        list[dict[str, Any]],
-        list[type[_BaseToolT]] | None,
-        dict[str, Any],
-    ]: ...
-
-    def __call__(
-        self,
-        *,
-        model: str,
-        client: _BaseClientT | None,
-        fn: Callable[_P, _BaseDynamicConfigT | Awaitable[_BaseDynamicConfigT]],
-        fn_args: dict[str, Any],
-        dynamic_config: _BaseDynamicConfigT,
-        tools: list[type[BaseTool] | Callable] | None,
-        json_mode: bool,
-        call_params: _BaseCallParamsT,
-        extract: bool,
-    ) -> tuple[
-        CreateFn[_ResponseT, _ResponseChunkT]
-        | AsyncCreateFn[_ResponseT, _ResponseChunkT],
-        str,
-        list[dict[str, Any]],
-        list[type[_BaseToolT]] | None,
-        dict[str, Any],
-    ]: ...  # pragma: no cover
-
-    @staticmethod
-    def fn_is_sync(
-        fn: Callable[_P, _R | Awaitable[_R]],
-    ) -> TypeGuard[Callable[_P, _R]]:
-        return not inspect.iscoroutinefunction(fn)
-
-    @staticmethod
-    def fn_is_async(
-        fn: Callable[_P, _R | Awaitable[_R]],
-    ) -> TypeGuard[Callable[_P, Awaitable[_R]]]:
-        return inspect.iscoroutinefunction(fn)
-
-
-class HandleStream(
-    Protocol[_InvariantResponseChunkT, _BaseCallResponseChunkT, _BaseToolT]
-):
-    def __call__(
-        self,
-        stream: Generator[_InvariantResponseChunkT, None, None],
-        tool_types: list[type[_BaseToolT]] | None,
-    ) -> Generator[
-        tuple[_BaseCallResponseChunkT, _BaseToolT | None], None, None
-    ]: ...  # pragma: no cover
-
-
-class HandleStreamAsync(
-    Protocol[_InvariantResponseChunkT, _BaseCallResponseChunkT, _BaseToolT]
-):
-    def __call__(
-        self,
-        stream: AsyncGenerator[_InvariantResponseChunkT, None],
-        tool_types: list[type[_BaseToolT]] | None,
-    ) -> AsyncGenerator[
-        tuple[_BaseCallResponseChunkT, _BaseToolT | None], None
-    ]: ...  # pragma: no cover
-
-
-class GetJsonOutput(Protocol[_R]):
-    def __call__(self, response: _R, json_mode: bool) -> str: ...  # pragma: no cover
-
-
-class CalculateCost(Protocol):
-    def __call__(
-        self,
-        input_tokens: int | float | None,
-        output_tokens: int | float | None,
-        model: str,
-    ) -> float | None: ...  # pragma: no cover

mirascope/core/base/_utils/_setup_call.py

@@ -1,64 +0,0 @@
-"""Utility for setting up a provider-specific call."""
-
-import inspect
-from collections.abc import Awaitable, Callable
-from typing import Any, TypeVar
-
-from ..call_params import BaseCallParams
-from ..dynamic_config import BaseDynamicConfig
-from ..message_param import BaseMessageParam
-from ..tool import BaseTool
-from ._convert_base_model_to_base_tool import convert_base_model_to_base_tool
-from ._convert_function_to_base_tool import convert_function_to_base_tool
-from ._get_prompt_template import get_prompt_template
-from ._parse_prompt_messages import parse_prompt_messages
-
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", bound=BaseDynamicConfig)
-
-
-def setup_call(
-    fn: Callable[..., _BaseDynamicConfigT | Awaitable[_BaseDynamicConfigT]],
-    fn_args: dict[str, Any],
-    dynamic_config: _BaseDynamicConfigT,
-    tools: list[type[BaseTool] | Callable] | None,
-    tool_type: type[_BaseToolT],
-    call_params: BaseCallParams,
-) -> tuple[
-    str,
-    list[BaseMessageParam | Any],
-    list[type[_BaseToolT]] | None,
-    dict[str, Any],
-]:
-    call_kwargs = call_params.copy()
-    prompt_template, messages, computed_fields = None, None, None
-    if dynamic_config is not None:
-        computed_fields = dynamic_config.get("computed_fields", None)
-        tools = dynamic_config.get("tools", tools)
-        messages = dynamic_config.get("messages", None)
-        dynamic_call_params = dynamic_config.get("call_params", None)
-        if dynamic_call_params:
-            call_kwargs |= dynamic_call_params
-
-    if not messages:
-        prompt_template = get_prompt_template(fn)
-        assert prompt_template is not None, "The function must have a docstring."
-        if computed_fields:
-            fn_args |= computed_fields
-        messages = parse_prompt_messages(
-            roles=["system", "user", "assistant"],
-            template=prompt_template,
-            attrs=fn_args,
-        )
-
-    tool_types = None
-    if tools:
-        tool_types = [
-            convert_base_model_to_base_tool(tool, tool_type)
-            if inspect.isclass(tool)
-            else convert_function_to_base_tool(tool, tool_type)
-            for tool in tools
-        ]
-        call_kwargs["tools"] = [tool_type.tool_schema() for tool_type in tool_types]  # type: ignore
-
-    return prompt_template, messages, tool_types, call_kwargs  # type: ignore

mirascope/core/base/_utils/_setup_extract_tool.py

@@ -1,24 +0,0 @@
-"""This module contains the `setup_extract_tool` function."""
-
-from abc import update_abstractmethods
-from typing import TypeVar
-
-from pydantic import BaseModel
-
-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
-
-BaseToolT = TypeVar("BaseToolT", bound=BaseModel)
-
-
-def setup_extract_tool(
-    response_model: type[BaseModel] | type[BaseType], tool_type: type[BaseToolT]
-) -> type[BaseToolT]:
-    if is_base_type(response_model):
-        converted_tool_type = convert_base_type_to_base_tool(response_model, tool_type)  # type: ignore
-    else:
-        converted_tool_type = convert_base_model_to_base_tool(response_model, tool_type)  # type: ignore
-    if not hasattr(response_model, "call"):
-        converted_tool_type.call = lambda self: ""  # pyright: ignore [reportAttributeAccessIssue]
-    return update_abstractmethods(converted_tool_type)

mirascope/core/base/call_params.py

@@ -1,6 +0,0 @@
-"""This module contains the type definition for the base call parameters."""
-
-from typing_extensions import TypedDict
-
-
-class BaseCallParams(TypedDict, total=False): ...  # pragma: no cover