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

mirascope/core/base/_utils/_get_possible_user_message_param.py

@@ -1,21 +0,0 @@
-"""Utility for getting the possible most recent user message."""
-
-from typing import TypeVar
-
-_T = TypeVar("_T")
-
-
-def get_possible_user_message_param(messages: list[_T]) -> _T | None:
-    """Get the possible most recent user message."""
-    if not messages:
-        return None
-    most_recent_message = messages[-1]
-    if (
-        isinstance(most_recent_message, dict)
-        and "role" in most_recent_message
-        and most_recent_message["role"] == "user"
-    ):
-        return most_recent_message
-    if hasattr(most_recent_message, "role") and most_recent_message.role == "user":  # pyright: ignore [reportAttributeAccessIssue]
-        return most_recent_message
-    return None

mirascope/core/base/_utils/_get_prompt_template.py

@@ -1,28 +0,0 @@
-"""Utility for pulling the `prompt_template` from a call or `BasePrompt`."""
-
-import os
-from collections.abc import Callable
-from textwrap import dedent
-
-from pydantic import BaseModel
-
-
-def get_prompt_template(fn: Callable | BaseModel) -> str:
-    """Get the metadata from the function and merge with any dynamic metadata."""
-
-    prompt_template = getattr(fn, "prompt_template", None) or getattr(
-        fn, "_prompt_template", None
-    )
-    if prompt_template:
-        return prompt_template
-
-    docstring_prompt_enabled = os.getenv("MIRASCOPE_DOCSTRING_PROMPT_TEMPLATE")
-    doc = fn.__doc__
-    if not doc:
-        raise ValueError("No prompt template set!")
-    if docstring_prompt_enabled != "ENABLED":
-        raise ValueError(
-            "You must explicitly enable docstring prompt templates by setting "
-            "`MIRASCOPE_DOCSTRING_PROMPT_TEMPLATE=ENABLED` in your environment."
-        )
-    return dedent(doc).strip()

mirascope/core/base/_utils/_get_template_values.py

@@ -1,51 +0,0 @@
-"""This module contains the `get_template_values` function."""
-
-from typing import Any
-
-
-def get_template_values(
-    template_variables: list[tuple[str, str | None]], attrs: dict[str, Any]
-) -> dict[str, Any]:
-    """Returns the values of the given `template_variables` from the provided `attrs`.
-
-    Args:
-        template_variables: The variables to extract from the `attrs`.
-        attrs: The attributes to extract the variables from.
-
-    Returns:
-        The values of the template variables.
-    """
-    values = {}
-    if "self" in attrs:
-        values["self"] = attrs.get("self")
-    for var, format_spec in template_variables:
-        if var.startswith("self"):
-            values["self"] = attrs.get("self")
-        elif "." in var:
-            var = var.split(".")[0]
-            values[var] = attrs.get(var)
-            continue
-        elif format_spec in ["list", "lists"]:
-            value = attrs[var]
-            if format_spec == "list":
-                if not isinstance(value, list):
-                    raise ValueError(
-                        f"Template variable '{var}' must be a list when using the "
-                        "'list' format spec."
-                    )
-                values[var] = "\n".join([str(item) for item in attrs[var]])
-            else:
-                if not isinstance(value, list) or (
-                    value
-                    and not all(isinstance(item, list | tuple | set) for item in value)
-                ):
-                    raise ValueError(
-                        f"Template variable '{var}' must be a list of lists when using "
-                        "the 'lists' format spec."
-                    )
-                values[var] = "\n\n".join(
-                    ["\n".join([str(subitem) for subitem in item]) for item in value]
-                )
-        else:
-            values[var] = attrs[var] if attrs[var] is not None else ""
-    return values

mirascope/core/base/_utils/_get_template_variables.py

@@ -1,38 +0,0 @@
-"""This module provides a function to get the variables in a template string."""
-
-from string import Formatter
-from typing import Literal, overload
-
-
-@overload
-def get_template_variables(
-    template: str, include_format_spec: Literal[True]
-) -> list[tuple[str, str | None]]: ...
-
-
-@overload
-def get_template_variables(
-    template: str, include_format_spec: Literal[False]
-) -> list[str]: ...
-
-
-def get_template_variables(
-    template: str, include_format_spec: bool
-) -> list[str] | list[tuple[str, str | None]]:
-    """Returns the variables in the given template string.
-
-    Args:
-        template: The template string to parse.
-        include_format_spec: A boolean indicating whether to include format specifications.
-
-    Returns:
-        The variables in the template string.
-    """
-    if include_format_spec:
-        return [
-            (var, format_spec)
-            for _, var, format_spec, _ in Formatter().parse(template)
-            if var
-        ]
-    else:
-        return [var for _, var, _, _ in Formatter().parse(template) if var]

mirascope/core/base/_utils/_get_unsupported_tool_config_keys.py

@@ -1,10 +0,0 @@
-"""Utility for getting provider-specific valid tool configuration keys."""
-
-from ..tool import ToolConfig
-
-
-def get_unsupported_tool_config_keys(
-    tool_config: ToolConfig, provider_config_type: type[ToolConfig]
-) -> set[str]:
-    """Returns the list of valid tool configuration keys for the specific provider."""
-    return set(tool_config) - set(provider_config_type.__annotations__.keys())

mirascope/core/base/_utils/_is_prompt_template.py

@@ -1,24 +0,0 @@
-"""Utility for determining if a prompt template has been decorated."""
-
-from collections.abc import Awaitable, Callable
-from typing import ParamSpec
-
-from typing_extensions import TypeIs
-
-from ..dynamic_config import BaseDynamicConfig
-from ..messages import Messages
-
-_P = ParamSpec("_P")
-
-
-def is_prompt_template(
-    fn: Callable[..., BaseDynamicConfig | Messages.Type]
-    | Callable[..., Awaitable[BaseDynamicConfig | Messages.Type]],
-) -> TypeIs[
-    Callable[..., BaseDynamicConfig]
-    | Callable[
-        ...,
-        Awaitable[BaseDynamicConfig],
-    ]
-]:
-    return hasattr(fn, "__mirascope_prompt_template__")

mirascope/core/base/_utils/_json_mode_content.py

@@ -1,17 +0,0 @@
-"""A function generating content to request JSON mode from models without it."""
-
-import json
-
-from pydantic import BaseModel
-
-from ..tool import GenerateJsonSchemaNoTitles
-
-
-def json_mode_content(tool_type: type[BaseModel] | None) -> str:
-    """Returns the content to request JSON mode from models without it."""
-    if not tool_type:
-        return "\n\nFor your final response, output ONLY a valid JSON dict that adheres to the schema"
-    return f"""
-
-For your final response, output ONLY a valid JSON dict (NOT THE SCHEMA) from the content that adheres to this schema:
-{json.dumps(tool_type.model_json_schema(schema_generator=GenerateJsonSchemaNoTitles), indent=2)}"""

mirascope/core/base/_utils/_messages_decorator.py

@@ -1,121 +0,0 @@
-from collections.abc import Awaitable, Callable, Sequence
-from functools import wraps
-from typing import ParamSpec, Protocol, TypeAlias, TypeVar, overload
-
-from typing_extensions import TypeIs
-
-from ..dynamic_config import BaseDynamicConfig
-from ..message_param import BaseMessageParam
-from ..messages import Messages
-from ._convert_messages_to_message_params import (
-    convert_messages_to_message_params,
-)
-from ._fn_is_async import fn_is_async
-
-_P = ParamSpec("_P")
-
-_MessageFuncReturnTypes: TypeAlias = BaseDynamicConfig | Messages.Type
-_MessageFuncReturnT = TypeVar(
-    "_MessageFuncReturnT", bound=_MessageFuncReturnTypes, contravariant=True
-)
-
-MessagesSyncFunction: TypeAlias = Callable[_P, _MessageFuncReturnT]
-MessagesAsyncFunction: TypeAlias = Callable[_P, Awaitable[_MessageFuncReturnT]]
-
-
-def _is_messages_type(value: object) -> TypeIs[Messages.Type]:
-    return isinstance(
-        value,
-        str | Sequence | list | BaseMessageParam,
-    )
-
-
-class MessagesDecorator(Protocol):
-    @overload
-    def __call__(
-        self,
-        messages_fn: Callable[_P, Messages.Type],
-    ) -> Callable[_P, list[BaseMessageParam]]: ...
-
-    @overload
-    def __call__(
-        self,
-        messages_fn: Callable[_P, BaseDynamicConfig],
-    ) -> Callable[_P, BaseDynamicConfig]: ...
-
-    @overload
-    def __call__(
-        self,
-        messages_fn: Callable[_P, Awaitable[Messages.Type]],
-    ) -> Callable[_P, Awaitable[list[BaseMessageParam]]]: ...
-
-    @overload
-    def __call__(
-        self,
-        messages_fn: Callable[_P, Awaitable[BaseDynamicConfig]],
-    ) -> Callable[_P, Awaitable[BaseDynamicConfig]]: ...
-
-    def __call__(
-        self,
-        messages_fn: MessagesSyncFunction[_P, _MessageFuncReturnT]
-        | MessagesAsyncFunction[_P, _MessageFuncReturnT],
-    ) -> (
-        Callable[_P, list[BaseMessageParam] | BaseDynamicConfig]
-        | Callable[_P, Awaitable[list[BaseMessageParam] | BaseDynamicConfig]]
-    ): ...
-
-
-def messages_decorator() -> MessagesDecorator:
-    @overload
-    def inner(
-        messages_fn: Callable[_P, Messages.Type],
-    ) -> Callable[_P, list[BaseMessageParam]]: ...
-
-    @overload
-    def inner(
-        messages_fn: Callable[_P, BaseDynamicConfig],
-    ) -> Callable[_P, BaseDynamicConfig]: ...
-
-    @overload
-    def inner(
-        messages_fn: Callable[_P, Awaitable[Messages.Type]],
-    ) -> Callable[_P, Awaitable[list[BaseMessageParam]]]: ...
-
-    @overload
-    def inner(
-        messages_fn: Callable[_P, Awaitable[BaseDynamicConfig]],
-    ) -> Callable[_P, Awaitable[BaseDynamicConfig]]: ...
-
-    def inner(
-        messages_fn: MessagesSyncFunction[_P, _MessageFuncReturnT]
-        | MessagesAsyncFunction[_P, _MessageFuncReturnT],
-    ) -> (
-        Callable[_P, Awaitable[list[BaseMessageParam] | BaseDynamicConfig]]
-        | Callable[_P, list[BaseMessageParam] | BaseDynamicConfig]
-    ):
-        if fn_is_async(messages_fn):
-
-            @wraps(messages_fn)
-            async def get_base_message_params_async(
-                *args: _P.args, **kwargs: _P.kwargs
-            ) -> list[BaseMessageParam] | BaseDynamicConfig:
-                raw_messages = await messages_fn(*args, **kwargs)
-                if _is_messages_type(raw_messages):
-                    return convert_messages_to_message_params(raw_messages)
-                return raw_messages
-
-            return get_base_message_params_async
-        else:
-
-            @wraps(messages_fn)
-            def get_base_message_params(
-                *args: _P.args, **kwargs: _P.kwargs
-            ) -> list[BaseMessageParam] | BaseDynamicConfig:
-                raw_messages = messages_fn(*args, **kwargs)
-                if _is_messages_type(raw_messages):
-                    return convert_messages_to_message_params(raw_messages)
-                return raw_messages
-
-            return get_base_message_params
-
-    return inner

mirascope/core/base/_utils/_parse_content_template.py

@@ -1,321 +0,0 @@
-"""This module provides a function to parse content parts from a prompt template."""
-
-import re
-import urllib.request
-from functools import reduce
-from typing import Any, Literal, cast
-
-from typing_extensions import TypedDict
-
-from ..message_param import (
-    AudioPart,
-    AudioURLPart,
-    BaseMessageParam,
-    CacheControlPart,
-    DocumentPart,
-    ImagePart,
-    ImageURLPart,
-    TextPart,
-)
-from ..types import Image, has_pil_module
-from ._format_template import format_template
-from ._get_audio_type import get_audio_type
-from ._get_document_type import get_document_type
-from ._get_image_type import get_image_type
-from ._pil_image_to_bytes import pil_image_to_bytes
-
-_PartType = Literal[
-    "image",
-    "images",
-    "audio",
-    "audios",
-    "text",
-    "texts",
-    "document",
-    "documents",
-    "cache_control",
-    "part",
-    "parts",
-]
-
-
-class _Part(TypedDict):
-    template: str
-    type: _PartType
-    options: dict[str, str] | None
-
-
-def _cleanup_text_preserve_newlines(text: str) -> str:
-    def clean_line(line: str) -> str:
-        # Remove '\r' to handle Windows-style line breaks
-        line = line.replace("\r", "")
-
-        # Remove zero-width spaces (common examples)
-        zero_width_spaces = ["\u200b", "\u200c", "\u200d", "\ufeff"]
-        for zw in zero_width_spaces:
-            line = line.replace(zw, "")
-
-        # Remove all fullwidth spaces (u3000) anywhere in the line
-        line = line.replace("\u3000", "")
-
-        # Strip leading/trailing half-width spaces (but keep tabs/newlines)
-        line = line.strip(" ")
-
-        # Remove leading tabs
-        line = line.lstrip("\t")
-        # Remove trailing tabs
-        line = line.rstrip("\t")
-
-        return line
-
-    # Split lines but preserve the newline at the end of each line
-    lines = text.splitlines(keepends=True)
-
-    # Use `map` to apply `clean_line` to each line
-    cleaned_lines = map(clean_line, lines)
-
-    # Use `reduce` to concatenate all lines into a single string
-    return reduce(lambda acc, x: acc + x, cleaned_lines, "")
-
-
-def _parse_parts(template: str) -> list[_Part]:
-    # \{ and \} match the literal curly braces.
-    #
-    # ([^:{}]*) captures content before the colon that are not { or } or :.
-    # This can be empty when using `cache_control`.
-    #
-    # : matches the literal colon separating the type from the content.
-    #
-    # (image|images|...) captures the supported special type after the colon.
-    #
-    # (?:\(([^)]*)\))? captures the optional additional options in parentheses.
-    pattern = r"\{([^:{}]*):(image|images|audio|audios|document|documents|text|texts|cache_control|part|parts)(?:\(([^)]*)\))?\}"
-    split = re.split(pattern, template)
-    parts: list[_Part] = []
-    for i in range(0, len(split), 4):
-        if split[i]:
-            parts.append(
-                _Part(
-                    template=_cleanup_text_preserve_newlines(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://", "data:", "file://")):
-            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 | Image.Image, options: dict[str, str] | None
-) -> ImagePart | ImageURLPart:
-    detail = None
-    if options:
-        detail = options.get("detail", None)
-    if isinstance(source, str) and source.startswith(("http://", "https://", "gs://")):
-        return ImageURLPart(type="image_url", url=source, detail=detail)
-    if isinstance(source, Image.Image):
-        image = pil_image_to_bytes(source)
-        media_type = (
-            Image.MIME[source.format]
-            if has_pil_module and source.format
-            else "image/unknown"
-        )
-    else:
-        image = _load_media(source)
-        media_type = f"image/{get_image_type(image)}"
-    return ImagePart(
-        type="image",
-        media_type=media_type,
-        image=image,
-        detail=detail,
-    )
-
-
-def _construct_audio_part(source: str | bytes) -> AudioPart | AudioURLPart:
-    # Note: audio does not currently support additional options, at least for now.
-    if isinstance(source, str) and source.startswith(("http://", "https://", "gs://")):
-        return AudioURLPart(type="audio_url", url=source)
-    audio = _load_media(source)
-    return AudioPart(
-        type="audio", media_type=f"audio/{get_audio_type(audio)}", audio=audio
-    )
-
-
-def _construct_document_part(source: str | bytes) -> DocumentPart:
-    document = _load_media(source)
-    return DocumentPart(
-        type="document",
-        media_type=f"application/{get_document_type(document)}",
-        document=document,
-    )
-
-
-def _construct_parts(
-    part: _Part, attrs: dict[str, Any]
-) -> list[
-    TextPart
-    | ImagePart
-    | ImageURLPart
-    | AudioPart
-    | AudioURLPart
-    | CacheControlPart
-    | DocumentPart
-]:
-    if part["type"] in "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 []
-    elif part["type"] == "document":
-        source = attrs[part["template"]]
-        return [_construct_document_part(source)] if source else []
-    elif part["type"] == "documents":
-        sources = attrs[part["template"]]
-        if not isinstance(sources, list):
-            raise ValueError(
-                f"When using 'documents' template, '{part['template']}' must be a list."
-            )
-        return (
-            [_construct_document_part(source) for source in sources] if sources else []
-        )
-    elif part["type"] == "cache_control":
-        return [
-            CacheControlPart(
-                type="cache_control",
-                cache_type=part["options"].get("type", "ephemeral")
-                if part["options"]
-                else "ephemeral",
-            )
-        ]
-    elif part["type"] == "part":
-        source = attrs[part["template"]]
-        if not isinstance(
-            source,
-            TextPart
-            | ImagePart
-            | ImageURLPart
-            | AudioPart
-            | AudioURLPart
-            | CacheControlPart
-            | DocumentPart,
-        ):
-            raise ValueError(
-                f"When using 'part' template, '{part['template']}' must be a valid content part."
-            )
-        return [source] if source else []
-    elif part["type"] == "parts":
-        sources = attrs[part["template"]]
-        if not isinstance(sources, list):
-            raise ValueError(
-                f"When using 'parts' template, '{part['template']}' must be a list."
-            )
-
-        # validate each part is a valid content part
-        for source in sources:
-            if not isinstance(
-                source,
-                TextPart
-                | ImagePart
-                | ImageURLPart
-                | AudioPart
-                | AudioURLPart
-                | CacheControlPart
-                | DocumentPart,
-            ):
-                raise ValueError(
-                    f"When using 'parts' template, '{part['template']}' must be a list of valid content parts."
-                )
-        return sources if sources else []
-    elif part["type"] == "texts":
-        sources = attrs[part["template"]]
-        if not isinstance(sources, list):
-            raise ValueError(
-                f"When using 'texts' template, '{part['template']}' must be a list."
-            )
-        return (
-            [TextPart(type="text", text=source) for source in sources]
-            if sources
-            else []
-        )
-    else:  # text type
-        text = part["template"]
-        if text in attrs:
-            source = attrs[text]
-            return [TextPart(type="text", text=source)]
-        formatted_template = format_template(part["template"], attrs, strip=False)
-        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.strip())
-        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)