mirascope 1.25.7__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

mirascope/core/base/_utils/_convert_messages_to_message_params.py

@@ -1,178 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Sequence
-from io import FileIO
-from typing import cast
-from wave import Wave_read
-
-from pydantic import BaseModel
-from typing_extensions import TypeIs
-
-from ..message_param import (
-    AudioPart,
-    AudioURLPart,
-    BaseMessageParam,
-    CacheControlPart,
-    DocumentPart,
-    DocumentURLPart,
-    ImagePart,
-    ImageURLPart,
-    TextPart,
-)
-from ..types import AudioSegment, Image, has_pil_module, has_pydub_module
-from ._pil_image_to_bytes import pil_image_to_bytes
-
-SAMPLE_WIDTH = 2
-FRAME_RATE = 24000
-CHANNELS = 1
-
-
-def _convert_message_sequence_part_to_content_part(
-    message_sequence_part: str
-    | TextPart
-    | CacheControlPart
-    | ImagePart
-    | ImageURLPart
-    | Image.Image
-    | AudioPart
-    | AudioURLPart
-    | AudioSegment
-    | Wave_read
-    | DocumentPart
-    | DocumentURLPart,
-) -> (
-    TextPart
-    | ImagePart
-    | ImageURLPart
-    | AudioPart
-    | AudioURLPart
-    | CacheControlPart
-    | DocumentURLPart
-    | DocumentPart
-):
-    if isinstance(message_sequence_part, str):
-        return TextPart(text=message_sequence_part, type="text")
-    elif isinstance(
-        message_sequence_part,
-        TextPart
-        | ImagePart
-        | ImageURLPart
-        | AudioPart
-        | AudioURLPart
-        | CacheControlPart
-        | DocumentPart
-        | DocumentURLPart,
-    ):
-        return message_sequence_part
-    elif has_pil_module and isinstance(message_sequence_part, Image.Image):
-        media_type = (
-            Image.MIME[message_sequence_part.format]
-            if message_sequence_part.format
-            else "image/unknown"
-        )
-        return ImagePart(
-            type="image",
-            media_type=media_type,
-            image=pil_image_to_bytes(message_sequence_part),
-            detail=None,
-        )
-    elif has_pydub_module and isinstance(message_sequence_part, AudioSegment):
-        return AudioPart(
-            type="audio",
-            media_type="audio/wav",
-            audio=cast(
-                FileIO,
-                message_sequence_part.set_frame_rate(FRAME_RATE)
-                .set_channels(CHANNELS)
-                .set_sample_width(SAMPLE_WIDTH)
-                .export(format="wav"),
-            ).read(),
-        )
-    elif isinstance(message_sequence_part, Wave_read):
-        return AudioPart(
-            type="audio",
-            media_type="audio/wav",
-            audio=message_sequence_part.readframes(-1),
-        )
-    else:
-        raise ValueError(f"Invalid message sequence type: {message_sequence_part}")
-
-
-def convert_message_content_to_message_param_content(
-    message_sequence: Sequence[
-        str
-        | TextPart
-        | CacheControlPart
-        | ImagePart
-        | ImageURLPart
-        | Image.Image
-        | AudioPart
-        | AudioURLPart
-        | AudioSegment
-        | Wave_read
-        | DocumentPart
-        | DocumentURLPart,
-    ],
-) -> (
-    list[
-        TextPart
-        | ImagePart
-        | ImageURLPart
-        | AudioPart
-        | AudioURLPart
-        | CacheControlPart
-        | DocumentPart
-        | DocumentURLPart,
-    ]
-    | str
-):
-    if isinstance(message_sequence, str):
-        return message_sequence
-    return [
-        _convert_message_sequence_part_to_content_part(message)
-        for message in message_sequence
-    ]
-
-
-def _is_base_message_params(
-    value: object,
-) -> TypeIs[list[BaseMessageParam]]:
-    # Note: we also need to catch the original provider message parameters here
-    return isinstance(value, list) and all(
-        isinstance(v, BaseMessageParam | dict | BaseModel) for v in value
-    )
-
-
-def convert_messages_to_message_params(
-    messages: str
-    | Sequence[
-        str
-        | TextPart
-        | CacheControlPart
-        | ImagePart
-        | ImageURLPart
-        | Image.Image
-        | AudioPart
-        | AudioURLPart
-        | AudioSegment
-        | Wave_read
-        | DocumentPart
-        | DocumentURLPart,
-    ]
-    | list[BaseMessageParam]
-    | BaseMessageParam,
-    role: str = "user",
-) -> list[BaseMessageParam]:
-    if isinstance(messages, BaseMessageParam):
-        return [messages]
-    elif _is_base_message_params(messages):
-        return messages
-    elif isinstance(messages, str | Sequence):
-        return [
-            BaseMessageParam(
-                content=convert_message_content_to_message_param_content(messages),
-                role=role,
-            )
-        ]
-    else:
-        raise ValueError(f"Invalid messages type: {messages}")

mirascope/core/base/_utils/_convert_provider_finish_reason_to_finish_reason.py

@@ -1,20 +0,0 @@
-from typing import Literal, TypeAlias, cast
-
-from mirascope.core.base.types import FinishReason
-
-FinishReasonMappingValue: TypeAlias = Literal[
-    "stop", "length", "tool_calls", "content_filter"
-]
-
-
-def _convert_finish_reasons_to_common_finish_reasons_from_mapping(
-    finish_reasons: list[str] | None, mapping: dict[str, FinishReasonMappingValue]
-) -> list[FinishReason] | None:
-    """Provider-agnostic finish reasons."""
-    if not finish_reasons:
-        return None
-    return [
-        cast(FinishReason, mapping[reason])
-        for reason in finish_reasons
-        if reason in mapping
-    ] or None

mirascope/core/base/_utils/_default_tool_docstring.py

@@ -1,6 +0,0 @@
-"""The default docstring to use when tools don't have a docstring."""
-
-DEFAULT_TOOL_DOCSTRING = """\
-Correctly formatted and typed parameters extracted from the completion. \
-Must include required parameters and may exclude optional parameters unless present in the text.\
-"""

mirascope/core/base/_utils/_extract_tool_return.py

@@ -1,42 +0,0 @@
-"""This module contains the function to extract the return value of a tool."""
-
-from typing import Any, TypeAlias, TypeVar
-
-import jiter
-from pydantic import BaseModel
-
-from .._partial import partial
-from ._base_type import BaseType, is_base_type
-from ._convert_base_type_to_base_tool import convert_base_type_to_base_tool
-
-_BaseModelT = TypeVar("_BaseModelT", bound=BaseModel)
-_BaseTypeT = TypeVar("_BaseTypeT", bound=BaseType)
-
-_ResponseModelT: TypeAlias = _BaseModelT | _BaseTypeT
-
-
-def extract_tool_return(
-    response_model: type[_ResponseModelT],
-    json_output: str | object,
-    allow_partial: bool,
-    fields_from_call_args: dict[str, Any],
-) -> _ResponseModelT:
-    json_obj = (
-        jiter.from_json(
-            json_output.encode(),
-            partial_mode="trailing-strings" if allow_partial else "off",
-        )
-        if json_output and isinstance(json_output, str)
-        else json_output or {}
-    )
-    if is_base_type(response_model):
-        temp_model = convert_base_type_to_base_tool(response_model, BaseModel)
-        if allow_partial:
-            return partial(temp_model).model_validate(json_obj).value  # pyright: ignore [reportAttributeAccessIssue]
-        return temp_model.model_validate(json_obj).value  # pyright: ignore [reportAttributeAccessIssue]
-    if fields_from_call_args and isinstance(json_obj, dict):
-        # Support only top-level dict
-        json_obj.update(fields_from_call_args)
-    if allow_partial:
-        return partial(response_model).model_validate(json_obj)
-    return response_model.model_validate(json_obj)

mirascope/core/base/_utils/_fn_is_async.py

@@ -1,24 +0,0 @@
-"""This module contains the `fn_is_async` function."""
-
-import inspect
-from collections.abc import Awaitable, Callable, Coroutine
-from typing import Any, TypeVar
-
-from typing_extensions import TypeIs
-
-_R = TypeVar("_R")
-
-
-def fn_is_async(
-    fn: Callable[..., Awaitable[_R] | Coroutine[Any, Any, _R]] | Callable[..., _R],
-) -> TypeIs[Callable[..., Awaitable[_R]]]:
-    if inspect.iscoroutinefunction(fn):
-        return True
-
-    # Check if it's a wrapper around an `async def` function (using functools.wraps).
-    _fn = fn
-    while hasattr(_fn, "__wrapped__"):
-        _fn = _fn.__wrapped__  # pyright: ignore[reportFunctionMemberAccess]
-        if inspect.iscoroutinefunction(_fn):
-            return True
-    return False

mirascope/core/base/_utils/_format_template.py

@@ -1,32 +0,0 @@
-"""This module contains the `format_template` function."""
-
-from textwrap import dedent
-from typing import Any
-
-from ._get_template_values import get_template_values
-from ._get_template_variables import get_template_variables
-
-
-def format_template(template: str, attrs: dict[str, Any], strip: bool = True) -> str:
-    """Formats the given prompt `template`
-
-    Args:
-        template: The template to format.
-        attrs: The attributes to use for formatting.
-        strip: Whether to strip the formatted template.
-
-    Returns:
-        The formatted template.
-
-    """
-    dedented_template = dedent(template)
-    if strip:
-        dedented_template = dedented_template.strip()
-    template_vars = get_template_variables(dedented_template, True)
-
-    values = get_template_values(template_vars, attrs)
-
-    # Remove any special format specs that are actually invalid normally
-    dedented_template = dedented_template.replace(":lists", "").replace(":list", "")
-    result = dedented_template.format(**values)
-    return result.strip() if strip else result

mirascope/core/base/_utils/_get_audio_type.py

@@ -1,18 +0,0 @@
-"""Utility for determining the type of an audio file from its bytes."""
-
-
-def get_audio_type(audio_data: bytes) -> str:
-    if audio_data.startswith(b"RIFF") and audio_data[8:12] == b"WAVE":
-        return "wav"
-    elif audio_data.startswith(b"ID3") or audio_data.startswith(b"\xff\xfb"):
-        return "mp3"
-    elif audio_data.startswith(b"FORM") and audio_data[8:12] == b"AIFF":
-        return "aiff"
-    elif audio_data.startswith(b"\xff\xf1") or audio_data.startswith(b"\xff\xf9"):
-        return "aac"
-    elif audio_data.startswith(b"OggS"):
-        return "ogg"
-    elif audio_data.startswith(b"fLaC"):
-        return "flac"
-
-    raise ValueError("Unsupported audio type")

mirascope/core/base/_utils/_get_common_usage.py

@@ -1,20 +0,0 @@
-from mirascope.core.base.types import Usage
-
-
-def get_common_usage(
-    input_tokens: int | float | None,
-    cached_tokens: int | float | None,
-    output_tokens: int | float | None,
-) -> Usage | None:
-    """Get common usage from input and output tokens."""
-    if input_tokens is None and cached_tokens is None and output_tokens is None:
-        return None
-    input_tokens = int(input_tokens or 0)
-    cached_tokens = int(cached_tokens or 0)
-    output_tokens = int(output_tokens or 0)
-    return Usage(
-        input_tokens=input_tokens,
-        cached_tokens=cached_tokens,
-        output_tokens=output_tokens,
-        total_tokens=input_tokens + output_tokens,
-    )

mirascope/core/base/_utils/_get_create_fn_or_async_create_fn.py

@@ -1,137 +0,0 @@
-import inspect
-from collections.abc import (
-    AsyncGenerator,
-    AsyncIterable,
-    AsyncIterator,
-    Awaitable,
-    Callable,
-    Coroutine,
-    Generator,
-    Iterable,
-    Iterator,
-)
-from typing import (
-    Any,
-    Literal,
-    TypeAlias,
-    TypeVar,
-    cast,
-    overload,
-)
-
-from typing_extensions import TypeIs
-
-from ..stream_config import StreamConfig
-from ._protocols import AsyncCreateFn, CreateFn
-
-_StreamedResponse = TypeVar("_StreamedResponse")
-_NonStreamedResponse = TypeVar("_NonStreamedResponse")
-_T = TypeVar("_T")
-
-
-def is_awaitable(value: _T | Awaitable[_T]) -> TypeIs[Awaitable[_T]]:
-    return inspect.isawaitable(value)
-
-
-_AsyncFunc: TypeAlias = Callable[..., Awaitable[_NonStreamedResponse]]
-_AsyncGeneratorFunc: TypeAlias = (
-    Callable[..., Awaitable[AsyncGenerator[_StreamedResponse, None]]]
-    | Callable[..., AsyncGenerator[_StreamedResponse, None]]
-    | Callable[..., AsyncIterator[_StreamedResponse]]
-    | Callable[..., AsyncIterable[_StreamedResponse]]
-    | Callable[..., Coroutine[Any, Any, _StreamedResponse]]
-)
-
-_SyncFunc: TypeAlias = Callable[..., _NonStreamedResponse]
-_SyncGeneratorFunc: TypeAlias = Callable[
-    ..., Iterator[_StreamedResponse] | Iterable[_StreamedResponse]
-]
-
-
-def get_async_create_fn(
-    async_func: _AsyncFunc[_NonStreamedResponse],
-    async_generator_func: _AsyncGeneratorFunc[_StreamedResponse] | None = None,
-) -> AsyncCreateFn[_NonStreamedResponse, _StreamedResponse]:
-    @overload
-    def create_or_stream(  # pyright: ignore[reportOverlappingOverload]
-        *,
-        stream: Literal[True] | StreamConfig = True,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> Awaitable[AsyncGenerator[_StreamedResponse, None]]: ...
-
-    @overload
-    def create_or_stream(
-        *,
-        stream: Literal[False] = False,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> Awaitable[_NonStreamedResponse]: ...
-
-    def create_or_stream(
-        *,
-        stream: bool | StreamConfig = False,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> (
-        Awaitable[AsyncGenerator[_StreamedResponse, None]]
-        | Awaitable[_NonStreamedResponse]
-    ):
-        if not stream:
-            return cast(Awaitable[_NonStreamedResponse], async_func(**kwargs))
-        else:
-            if async_generator_func is None:
-                async_generator = async_func(**kwargs, stream=True)
-            else:
-                async_generator = async_generator_func(**kwargs)
-            if inspect.isasyncgen(async_generator) or not is_awaitable(async_generator):
-
-                async def _stream() -> AsyncGenerator[_StreamedResponse]:
-                    return cast(AsyncGenerator[_StreamedResponse], async_generator)
-
-                return _stream()
-            else:
-                return cast(
-                    Awaitable[AsyncGenerator[_StreamedResponse]], async_generator
-                )
-
-    return create_or_stream
-
-
-def get_create_fn(
-    sync_func: _SyncFunc[_NonStreamedResponse],
-    sync_generator_func: _SyncGeneratorFunc[_StreamedResponse] | None = None,
-) -> CreateFn[_NonStreamedResponse, _StreamedResponse]:
-    @overload
-    def create_or_stream(  # pyright: ignore[reportOverlappingOverload]
-        *,
-        stream: Literal[True] | StreamConfig = True,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> Generator[_StreamedResponse, None, None]: ...
-
-    @overload
-    def create_or_stream(
-        *,
-        stream: Literal[False] = False,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> _NonStreamedResponse: ...
-
-    def create_or_stream(
-        *,
-        stream: bool | StreamConfig = False,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> Generator[_StreamedResponse, None, None] | _NonStreamedResponse:
-        if stream:
-            if sync_generator_func is None:
-                generator = cast(
-                    Iterator[_StreamedResponse],
-                    sync_func(**kwargs, stream=True),
-                )
-            else:
-                generator = sync_generator_func(**kwargs)
-
-            def _stream() -> Generator[_StreamedResponse, None, None]:
-                yield from generator
-
-            return _stream()
-
-        return cast(_NonStreamedResponse, sync_func(**kwargs))
-
-    return create_or_stream

mirascope/core/base/_utils/_get_document_type.py

@@ -1,7 +0,0 @@
-"""Utility for determining the type of an document from its bytes."""
-
-
-def get_document_type(document_data: bytes) -> str:
-    if document_data.startswith(b"%PDF"):
-        return "pdf"
-    raise ValueError("Unsupported document type")

mirascope/core/base/_utils/_get_dynamic_configuration.py

@@ -1,69 +0,0 @@
-import inspect
-from collections.abc import Awaitable, Callable
-from typing import Any, TypeVar, cast, overload
-
-from typing_extensions import TypeIs
-
-from ..dynamic_config import BaseDynamicConfig
-from ..message_param import BaseMessageParam
-
-_BaseDynamicConfigT = TypeVar(
-    "_BaseDynamicConfigT", bound=BaseDynamicConfig, covariant=True
-)
-
-_AsyncBaseDynamicConfigT = TypeVar(
-    "_AsyncBaseDynamicConfigT", bound=BaseDynamicConfig, covariant=True
-)
-
-
-def _is_message_param_list(result: object) -> TypeIs[list[BaseMessageParam]]:
-    return isinstance(result, list)
-
-
-@overload
-def get_dynamic_configuration(
-    fn: Callable[..., _BaseDynamicConfigT | list[BaseMessageParam]],
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> _BaseDynamicConfigT: ...
-
-
-@overload
-def get_dynamic_configuration(
-    fn: Callable[
-        ..., Awaitable[_AsyncBaseDynamicConfigT] | Awaitable[list[BaseMessageParam]]
-    ],
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> Awaitable[_AsyncBaseDynamicConfigT]: ...
-
-
-def get_dynamic_configuration(
-    fn: Callable[
-        ...,
-        _BaseDynamicConfigT
-        | list[BaseMessageParam]
-        | Awaitable[_AsyncBaseDynamicConfigT]
-        | Awaitable[list[BaseMessageParam]],
-    ],
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> _BaseDynamicConfigT | Awaitable[_AsyncBaseDynamicConfigT]:
-    result = (
-        fn._original_fn(*args, **kwargs)  # pyright: ignore [reportFunctionMemberAccess]
-        if hasattr(fn, "_original_fn")
-        else fn(*args, **kwargs)
-    )
-    if inspect.isawaitable(result):
-
-        async def inner_async() -> _AsyncBaseDynamicConfigT:
-            async_result = await result
-            if _is_message_param_list(async_result):
-                return cast(_AsyncBaseDynamicConfigT, {"messages": async_result})
-            return cast(_AsyncBaseDynamicConfigT, async_result)
-
-        return inner_async()
-
-    if _is_message_param_list(result):
-        return cast(_BaseDynamicConfigT, {"messages": result})
-    return result

mirascope/core/base/_utils/_get_fields_from_call_args.py

@@ -1,34 +0,0 @@
-"""Get FromCallArgs() annotated fields from a function call's args/kwargs."""
-
-import inspect
-from collections.abc import Callable
-from typing import Any, get_origin
-
-from pydantic import BaseModel
-
-from mirascope.core.base._utils import get_fn_args
-from mirascope.core.base.from_call_args import is_from_call_args
-
-
-def get_fields_from_call_args(
-    response_model: object,
-    fn: Callable,
-    args: tuple[object, ...],
-    kwargs: dict[str, Any],
-) -> dict[str, Any]:
-    if origin := get_origin(response_model):
-        response_model = origin
-    if not (inspect.isclass(response_model) and issubclass(response_model, BaseModel)):
-        return {}
-    call_args_fields = {
-        name
-        for name, field in response_model.model_fields.items()
-        if is_from_call_args(field)
-    }
-
-    fn_args = get_fn_args(fn, args, kwargs)
-    if not call_args_fields.issubset(fn_args.keys()):
-        raise ValueError(
-            f"The function arguments do not contain all the fields marked with `FromCallArgs`. {fn_args=}, {call_args_fields=}"
-        )
-    return {name: fn_args[name] for name in call_args_fields}

mirascope/core/base/_utils/_get_fn_args.py

@@ -1,23 +0,0 @@
-"""Function for binding `args` and `kwargs` as a dictionary to the fn's signature."""
-
-import inspect
-from collections.abc import Callable
-from typing import Any
-
-
-def get_fn_args(
-    fn: Callable, args: tuple[object, ...], kwargs: dict[str, Any]
-) -> dict[str, Any]:
-    """Returns the `args` and `kwargs` as a dictionary bound by `fn`'s signature."""
-    signature = inspect.signature(fn)
-    bound_args = signature.bind_partial(*args, **kwargs)
-    bound_args.apply_defaults()
-
-    fn_args = {}
-    for name, value in bound_args.arguments.items():
-        if signature.parameters[name].kind == inspect.Parameter.VAR_KEYWORD:
-            fn_args.update(value)
-        else:
-            fn_args[name] = value
-
-    return fn_args

mirascope/core/base/_utils/_get_image_dimensions.py

@@ -1,39 +0,0 @@
-import base64
-import io
-import re
-
-from ...base.types import Image, ImageMetadata, has_pil_module
-from ._parse_content_template import _load_media
-
-
-def get_image_dimensions(data_url: str) -> ImageMetadata | None:
-    """
-    Extract width and height from a base64 encoded image.
-
-    Args:
-        data_url: The data URL containing base64 encoded image data or External URL
-
-    Returns:
-        Dictionary with width and height, or None if extraction failed
-    """
-    try:
-        if data_url.startswith("http"):
-            binary_data = _load_media(data_url)
-        else:
-            # Extract the base64 data part from the URL
-            # Format is: data:[<media type>][;base64],<data>
-            pattern = r"data:image/[^;]+;base64,"
-            base64_data = re.sub(pattern, "", data_url)
-
-            # Decode the base64 data
-            binary_data = base64.b64decode(base64_data)
-
-        # Use PIL to open the image and get dimensions
-        if not has_pil_module:  # pragma: no cover
-            raise ImportError("PIL module is not available")
-        with Image.open(io.BytesIO(binary_data)) as image:
-            width, height = image.size
-
-        return ImageMetadata(width=width, height=height)
-    except Exception:
-        return None

mirascope/core/base/_utils/_get_image_type.py

@@ -1,26 +0,0 @@
-"""Utility for determining the type of an image from its bytes."""
-
-
-def get_image_type(image_data: bytes) -> str:
-    if image_data.startswith(b"\xff\xd8\xff"):
-        return "jpeg"
-    elif image_data.startswith(b"\x89PNG\r\n\x1a\n"):
-        return "png"
-    elif image_data.startswith(b"GIF87a") or image_data.startswith(b"GIF89a"):
-        return "gif"
-    elif image_data.startswith(b"RIFF") and image_data[8:12] == b"WEBP":
-        return "webp"
-    elif image_data[4:12] in (
-        b"ftypmif1",
-        b"ftypmsf1",
-        b"ftypheic",
-        b"ftypheix",
-        b"ftyphevc",
-        b"ftyphevx",
-    ):
-        subtype = image_data[8:12]
-        if subtype in (b"heic", b"heix"):
-            return "heic"
-        elif subtype in (b"mif1", b"msf1", b"hevc", b"hevx"):
-            return "heif"
-    raise ValueError("Unsupported image type")