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

mirascope/core/openai/tool.py

@@ -1,101 +0,0 @@
-"""The `OpenAITool` class for easy tool usage with OpenAI LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-from openai.types.chat import (
-    ChatCompletionMessageToolCall,
-    ChatCompletionToolParam,
-)
-from openai.types.shared_params import FunctionDefinition
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool, GenerateJsonSchemaNoTitles, ToolConfig
-from ..base._partial import partial
-
-
-class GenerateOpenAIStrictToolJsonSchema(GenerateJsonSchemaNoTitles):
-    _openai_strict = True
-
-
-class OpenAIToolConfig(ToolConfig, total=False):
-    """A tool configuration for OpenAI-specific features."""
-
-    strict: bool
-
-
-class OpenAITool(BaseTool):
-    """A class for defining tools for OpenAI LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.openai import openai_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @openai_call("gpt-4o-mini", tools=[format_book])
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `OpenAITool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "openai"
-    __tool_config_type__ = OpenAIToolConfig
-
-    tool_call: SkipJsonSchema[ChatCompletionMessageToolCall]
-
-    @classmethod
-    def tool_schema(cls) -> ChatCompletionToolParam:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.openai import OpenAITool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = OpenAITool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the OpenAI-specific tool schema
-        ```
-        """
-        fn = FunctionDefinition(name=cls._name(), description=cls._description())
-        schema_generator = GenerateJsonSchemaNoTitles
-        if cls.tool_config.get("strict", False):
-            fn["strict"] = True
-            schema_generator = GenerateOpenAIStrictToolJsonSchema
-        model_schema = cls.model_json_schema(schema_generator=schema_generator)
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema
-        return ChatCompletionToolParam(function=fn, type="function")
-
-    @classmethod
-    def from_tool_call(
-        cls, tool_call: ChatCompletionMessageToolCall, allow_partial: bool = False
-    ) -> OpenAITool:
-        """Constructs an `OpenAITool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The OpenAI tool call from which to construct this tool instance.
-            allow_partial: Whether to allow partial JSON data.
-        """
-        model_json = {"tool_call": tool_call.model_dump()}
-        if args := tool_call.function.arguments:
-            model_json |= cls._dict_from_json(args, allow_partial)
-        if allow_partial:
-            return partial(cls, {"tool_call", "delta"}).model_validate(model_json)
-        return cls.model_validate(model_json)

mirascope/core/vertex/__init__.py

@@ -1,45 +0,0 @@
-"""The Mirascope Vertex Module."""
-
-import inspect
-import warnings
-from typing import TypeAlias
-
-from google.cloud.aiplatform_v1beta1.types import FunctionResponse
-from vertexai.generative_models import Content
-
-from ..base import BaseMessageParam
-from ._call import vertex_call
-from ._call import vertex_call as call
-from .call_params import VertexCallParams
-from .call_response import VertexCallResponse
-from .call_response_chunk import VertexCallResponseChunk
-from .dynamic_config import VertexDynamicConfig
-from .stream import VertexStream
-from .tool import VertexTool
-
-VertexMessageParam: TypeAlias = Content | FunctionResponse | BaseMessageParam
-
-warnings.warn(
-    inspect.cleandoc("""
-    The `mirascope.core.gemini` module is deprecated and will be removed in a future release.
-    Please use the `mirascope.core.google` module instead.
-                     
-    You can use Vertex AI by setting a custom `client` or environment variables.
-    See these docs for reference:
-        - Google AI SDK Custom Client: https://googleapis.github.io/python-genai/#create-a-client
-        - Mirascope Google Custom Client: https://mirascope.com/learn/calls/#__tabbed_39_5
-    """),
-    category=DeprecationWarning,
-)
-
-__all__ = [
-    "VertexCallParams",
-    "VertexCallResponse",
-    "VertexCallResponseChunk",
-    "VertexDynamicConfig",
-    "VertexMessageParam",
-    "VertexStream",
-    "VertexTool",
-    "call",
-    "vertex_call",
-]

mirascope/core/vertex/_call.py

@@ -1,62 +0,0 @@
-"""The `vertex_call` decorator for functions as LLM calls."""
-
-from ..base import call_factory
-from ._utils import get_json_output, handle_stream, handle_stream_async, setup_call
-from .call_params import VertexCallParams
-from .call_response import VertexCallResponse
-from .call_response_chunk import VertexCallResponseChunk
-from .stream import VertexStream
-from .tool import VertexTool
-
-vertex_call = call_factory(
-    TCallResponse=VertexCallResponse,
-    TCallResponseChunk=VertexCallResponseChunk,
-    TStream=VertexStream,
-    TToolType=VertexTool,
-    default_call_params=VertexCallParams(),
-    setup_call=setup_call,
-    get_json_output=get_json_output,
-    handle_stream=handle_stream,  # pyright: ignore [reportArgumentType]
-    handle_stream_async=handle_stream_async,  # pyright: ignore [reportArgumentType]
-)
-"""A decorator for calling the Vertex API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Vertex API. It parses
-the prompt template of the wrapped function as the messages array and templates the
-input arguments for the function into each message's template.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.vertex import vertex_call
-
-
-@vertex_call("gemini-1.5-flash")
-def recommend_book(genre: str) -> str:
-    return f"Recommend a {genre} book"
-
-response = recommend_book("fantasy")
-print(response.content)
-```
-
-Args:
-    model (str): The Vertex model to use in the API call.
-    stream (bool): Whether to stream the response from the API call.
-    tools (list[BaseTool | Callable]): The tools to use in the Vertex API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[VertexCallResponse | ResponseModelT], Any]): A function
-        for parsing the call response whose value will be returned in place of the
-        original call response.
-    json_modem (bool): Whether to use JSON Mode.
-    client (object): An optional custom client to use in place of the default client.
-    call_params (VertexCallParams): The `VertexCallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a Vertex API
-        call.
-"""

mirascope/core/vertex/_call_kwargs.py

@@ -1,12 +0,0 @@
-"""This module contains the type definition for the Vertex call keyword arguments."""
-
-from collections.abc import Sequence
-
-from vertexai.generative_models import Content, Tool
-
-from ..base import BaseCallKwargs
-from .call_params import VertexCallParams
-
-
-class VertexCallKwargs(VertexCallParams, BaseCallKwargs[Tool]):
-    contents: Sequence[Content]

mirascope/core/vertex/_utils/__init__.py

@@ -1,14 +0,0 @@
-"""Vertex utilities for decorator factories."""
-
-from ._convert_message_params import convert_message_params
-from ._get_json_output import get_json_output
-from ._handle_stream import handle_stream, handle_stream_async
-from ._setup_call import setup_call
-
-__all__ = [
-    "convert_message_params",
-    "get_json_output",
-    "handle_stream",
-    "handle_stream_async",
-    "setup_call",
-]

mirascope/core/vertex/_utils/_convert_common_call_params.py

@@ -1,37 +0,0 @@
-from typing import cast
-
-from vertexai.generative_models import GenerationConfig
-
-from ...base.call_params import CommonCallParams
-from ..call_params import VertexCallParams
-
-VERTEX_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "max_output_tokens",
-    "top_p": "top_p",
-    "stop": "stop_sequences",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> VertexCallParams:
-    """Convert CommonCallParams to Vertex parameters."""
-    generation_config = {}
-
-    for key, value in common_params.items():
-        if key not in VERTEX_PARAM_MAPPING or value is None:
-            continue
-
-        if key == "stop":
-            generation_config["stop_sequences"] = (
-                [value] if isinstance(value, str) else value
-            )
-        else:
-            generation_config[VERTEX_PARAM_MAPPING[key]] = value
-
-    if not generation_config:
-        return cast(VertexCallParams, {})
-
-    return cast(
-        VertexCallParams,
-        {"generation_config": cast(GenerationConfig, generation_config)},
-    )

mirascope/core/vertex/_utils/_convert_finish_reason_to_common_finish_reasons.py

@@ -1,23 +0,0 @@
-from mirascope.core.base._utils._convert_provider_finish_reason_to_finish_reason import (
-    FinishReasonMappingValue,
-    _convert_finish_reasons_to_common_finish_reasons_from_mapping,
-)
-from mirascope.core.base.types import FinishReason
-
-_FinishReasonMapping: dict[str, FinishReasonMappingValue] = {
-    "FINISH_REASON_UNSPECIFIED": "stop",
-    "STOP": "stop",
-    "MAX_TOKENS": "length",
-    "SAFETY": "content_filter",
-    "RECITATION": "stop",
-    "OTHER": "stop",
-}
-
-
-def _convert_finish_reasons_to_common_finish_reasons(
-    finish_reasons: list[str],
-) -> list[FinishReason] | None:
-    """Provider-agnostic finish reasons."""
-    return _convert_finish_reasons_to_common_finish_reasons_from_mapping(
-        finish_reasons, _FinishReasonMapping
-    )

mirascope/core/vertex/_utils/_convert_message_params.py

@@ -1,171 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `Content`"""
-
-import base64
-import io
-
-import PIL.Image
-from google.cloud.aiplatform_v1beta1.types import content as gapic_content_types
-from google.cloud.aiplatform_v1beta1.types import tool as gapic_tool_types
-from vertexai.generative_models import Content, Image, Part
-
-from ...base import BaseMessageParam
-from ...base._utils import get_audio_type
-from ...base._utils._parse_content_template import _load_media
-
-
-def convert_message_params(
-    message_params: list[BaseMessageParam | Content],
-) -> list[Content]:
-    converted_message_params = []
-    for message_param in message_params:
-        if isinstance(message_param, Content):
-            converted_message_params.append(message_param)
-        elif (role := message_param.role) == "system":
-            content = message_param.content
-            if not isinstance(content, str):
-                raise ValueError(
-                    "System message content must be a single text string."
-                )  # pragma: no cover
-            converted_message_params += [
-                Content(
-                    role="system",
-                    parts=[
-                        Part.from_text(content) if isinstance(content, str) else content
-                    ],
-                ),
-            ]
-        elif isinstance((content := message_param.content), str):
-            converted_message_params.append(
-                Content(role="user", parts=[Part.from_text(content)])
-            )
-        else:
-            converted_content: list[Part] = []
-            for part in content:
-                if part.type == "text":
-                    converted_content.append(Part.from_text(part.text))
-                elif part.type == "image":
-                    if part.media_type not in [
-                        "image/jpeg",
-                        "image/png",
-                        "image/webp",
-                        "image/heic",
-                        "image/heif",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported image media type: {part.media_type}. "
-                            "Vertex currently only supports JPEG, PNG, WebP, HEIC, "
-                            "and HEIF images."
-                        )
-                    image = Image.from_bytes(part.image)
-                    converted_content.append(Part.from_image(image))
-                elif part.type == "image_url":
-                    # Should download the image to determine the media type
-                    image = PIL.Image.open(io.BytesIO(_load_media(part.url)))
-                    media_type = (
-                        PIL.Image.MIME[image.format]
-                        if image.format
-                        else "image/unknown"
-                    )
-                    if media_type not in [
-                        "image/jpeg",
-                        "image/png",
-                        "image/webp",
-                        "image/heic",
-                        "image/heif",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported image media type: {media_type}. "
-                            "Gemini currently only supports JPEG, PNG, WebP, HEIC, "
-                            "and HEIF images."
-                        )
-                    converted_content.append(
-                        Part.from_uri(part.url, mime_type=media_type)
-                    )
-                elif part.type == "audio":
-                    if part.media_type not in [
-                        "audio/wav",
-                        "audio/mp3",
-                        "audio/aiff",
-                        "audio/aac",
-                        "audio/ogg",
-                        "audio/flac",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported audio media type: {part.media_type}. "
-                            "Vertex currently only supports WAV, MP3, AIFF, AAC, OGG, "
-                            "and FLAC audio file types."
-                        )
-                    converted_content.append(
-                        Part.from_data(
-                            mime_type=part.media_type,
-                            data=part.audio
-                            if isinstance(part.audio, bytes)
-                            else base64.b64decode(part.audio),
-                        )
-                    )
-                elif part.type == "audio_url":
-                    # Should download the audio to determine the media type
-                    audio = _load_media(part.url)
-                    audio_type = f"audio/{get_audio_type(audio)}"
-                    if audio_type not in [
-                        "audio/wav",
-                        "audio/mp3",
-                        "audio/aiff",
-                        "audio/aac",
-                        "audio/ogg",
-                        "audio/flac",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported audio media type: {audio_type}. "
-                            "Gemini currently only supports WAV, MP3, AIFF, AAC, OGG, "
-                            "and FLAC audio file types."
-                        )
-                    converted_content.append(
-                        Part.from_uri(part.url, mime_type=audio_type)
-                    )
-                elif part.type == "tool_call":
-                    if converted_content:
-                        converted_message_params.append(
-                            Content(role=role, parts=converted_content)
-                        )
-                        converted_content = []
-                    raw_gapic_part = gapic_content_types.Part(
-                        function_call=gapic_tool_types.FunctionCall(
-                            name=part.name, args=part.args
-                        )
-                    )
-                    converted_message_params.append(
-                        Content(
-                            role=role,
-                            parts=[Part._from_gapic(raw_gapic_part)],
-                        )
-                    )
-                elif part.type == "tool_result":
-                    if converted_content:
-                        converted_message_params.append(
-                            Content(role=role, parts=converted_content)
-                        )
-                        converted_content = []
-                    converted_message_params.append(
-                        Content(
-                            role=role,
-                            parts=[
-                                Part.from_function_response(
-                                    name=part.name,
-                                    response={
-                                        "content": {"result": part.content},
-                                    },
-                                )
-                            ],
-                        )
-                    )
-                else:
-                    raise ValueError(
-                        "Vertex currently only supports text, image, and audio parts. "
-                        f"Part provided: {part.type}"
-                    )
-            if converted_content:
-                converted_message_params.append(
-                    Content(role=role, parts=converted_content)
-                )
-    return converted_message_params

mirascope/core/vertex/_utils/_get_json_output.py

@@ -1,36 +0,0 @@
-"""Get JSON output from a Vertex response."""
-
-import json
-
-from proto.marshal.collections import RepeatedComposite
-
-from ..call_response import VertexCallResponse
-from ..call_response_chunk import VertexCallResponseChunk
-
-
-def get_json_output(
-    response: VertexCallResponse | VertexCallResponseChunk, json_mode: bool
-) -> str:
-    """Extracts the JSON output from a Vertex response."""
-    if isinstance(response, VertexCallResponse):
-        if json_mode and (content := response.content):
-            json_start = content.index("{")
-            json_end = content.rfind("}")
-            return content[json_start : json_end + 1]
-        elif tool_calls := [
-            part.function_call
-            for candidate in response.response.candidates
-            for part in candidate.content.parts
-            if part.function_call.args
-        ]:
-            return json.dumps(
-                {
-                    k: v if not isinstance(v, RepeatedComposite) else list(v)
-                    for k, v in tool_calls[0].args.items()
-                }
-            )
-        else:
-            raise ValueError("No tool call or JSON object found in response.")
-    elif not json_mode:
-        raise ValueError("Vertex only supports structured streaming in json mode.")
-    return response.content

mirascope/core/vertex/_utils/_handle_stream.py

@@ -1,33 +0,0 @@
-"""Handles streaming content and tools from the Vertex API."""
-
-from collections.abc import AsyncGenerator, Generator
-
-from vertexai.generative_models import GenerationResponse
-
-from ..call_response_chunk import VertexCallResponseChunk
-from ..tool import VertexTool
-
-
-def handle_stream(
-    stream: Generator[GenerationResponse, None, None],
-    tool_types: list[type[VertexTool]] | None = None,
-) -> Generator[tuple[VertexCallResponseChunk, None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed.
-
-    Note: vertex does not currently support streaming tools.
-    """
-    for chunk in stream:
-        yield VertexCallResponseChunk(chunk=chunk), None
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[GenerationResponse, None],
-    tool_types: list[type[VertexTool]] | None = None,
-) -> AsyncGenerator[tuple[VertexCallResponseChunk, None], None]:
-    """
-    Async iterator over the stream and constructs tools as they are streamed.
-
-    Note: vertex does not currently support streaming tools.
-    """
-    async for chunk in stream:
-        yield VertexCallResponseChunk(chunk=chunk), None

mirascope/core/vertex/_utils/_message_param_converter.py

@@ -1,133 +0,0 @@
-from typing import cast
-
-from vertexai.generative_models import Content
-
-from mirascope.core import BaseMessageParam
-from mirascope.core.base import DocumentPart, ImagePart, TextPart
-from mirascope.core.base._utils._base_message_param_converter import (
-    BaseMessageParamConverter,
-)
-from mirascope.core.base.message_param import ImageURLPart, ToolCallPart, ToolResultPart
-from mirascope.core.vertex._utils import convert_message_params
-
-
-def _is_image_mime(mime_type: str) -> bool:
-    return mime_type in ["image/jpeg", "image/png", "image/gif", "image/webp"]
-
-
-def _to_image_part(mime_type: str, data: bytes) -> ImagePart:
-    if not _is_image_mime(mime_type):
-        raise ValueError(
-            f"Unsupported image media type: {mime_type}. "
-            "Expected one of: image/jpeg, image/png, image/gif, image/webp."
-        )
-    return ImagePart(type="image", media_type=mime_type, image=data, detail=None)
-
-
-def _to_document_part(mime_type: str, data: bytes) -> DocumentPart:
-    if mime_type != "application/pdf":
-        raise ValueError(
-            f"Unsupported document media type: {mime_type}. "
-            "Only application/pdf is supported."
-        )
-    return DocumentPart(type="document", media_type=mime_type, document=data)
-
-
-class VertexMessageParamConverter(BaseMessageParamConverter):
-    """Converts between Vertex `Content` and Mirascope `BaseMessageParam`."""
-
-    @staticmethod
-    def to_provider(message_params: list[BaseMessageParam]) -> list[Content]:
-        """
-        Convert from Mirascope `BaseMessageParam` to Vertex `Content`.
-        """
-        return convert_message_params(
-            cast(list[BaseMessageParam | Content], message_params)
-        )
-
-    @staticmethod
-    def from_provider(message_params: list[Content]) -> list[BaseMessageParam]:
-        """
-        Convert from Vertex's `Content` to Mirascope `BaseMessageParam`.
-        """
-        converted = []
-        for message_param in message_params:
-            role: str = (
-                "assistant" if message_param.role == "model" else message_param.role
-            )
-            contents = []
-            has_tool_call = False
-            for part in message_param.parts:
-                if part.function_response:
-                    converted.append(
-                        BaseMessageParam(
-                            role=message_param.role,
-                            content=[
-                                ToolResultPart(
-                                    type="tool_result",
-                                    name=part.function_response.name,
-                                    content=part.function_response.response["result"],  # pyright: ignore [reportReturnType, reportArgumentType]
-                                    id=None,
-                                    is_error=False,
-                                )
-                            ],
-                        )
-                    )
-                elif part.inline_data:
-                    blob = part.inline_data
-                    mime = blob.mime_type
-                    data = blob.data
-                    if _is_image_mime(mime):
-                        contents.append(_to_image_part(mime, data))
-                    elif mime == "application/pdf":
-                        contents.append(_to_document_part(mime, data))
-                    else:
-                        raise ValueError(
-                            f"Unsupported inline_data mime type: {mime}. Cannot convert to BaseMessageParam."
-                        )
-
-                elif part.file_data:
-                    if _is_image_mime(part.file_data.mime_type):
-                        contents.append(
-                            ImageURLPart(
-                                type="image_url",
-                                url=part.file_data.file_uri,
-                                detail=None,
-                            )
-                        )
-                    else:
-                        raise ValueError(
-                            f"FileData.file_uri is not support: {part.file_data}. Cannot convert to BaseMessageParam."
-                        )
-                elif part.function_call:
-                    converted.append(
-                        BaseMessageParam(
-                            role=role,
-                            content=[
-                                ToolCallPart(
-                                    type="tool_call",
-                                    name=part.function_call.name,
-                                    args=dict(part.function_call.args),
-                                )
-                            ],
-                        )
-                    )
-                elif part.text:
-                    contents.append(TextPart(type="text", text=part.text))
-
-                else:  # pragma: no cover
-                    raise ValueError(
-                        "Part does not contain any supported content (text, image, or document)."
-                    )
-
-            if len(contents) == 1 and isinstance(contents[0], TextPart):
-                converted.append(BaseMessageParam(role=role, content=contents[0].text))
-            else:
-                if contents:
-                    converted.append(
-                        BaseMessageParam(
-                            role="tool" if has_tool_call else role, content=contents
-                        )
-                    )
-
-        return converted