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

mirascope/core/google/_utils/_message_param_converter.py

@@ -1,162 +0,0 @@
-from typing import cast
-
-from google.genai import Client
-from google.genai.types import (
-    Content,
-    ContentDict,
-    ContentOrDict,
-)
-
-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 (
-    AudioPart,
-    AudioURLPart,
-    ImageURLPart,
-    ToolCallPart,
-    ToolResultPart,
-)
-from mirascope.core.google._utils import convert_message_params
-
-from ._validate_media_type import _check_audio_media_type, _check_image_media_type
-
-
-class GoogleMessageParamConverter(BaseMessageParamConverter):
-    """Converts between Google `ContentDict` and Mirascope `BaseMessageParam`."""
-
-    @staticmethod
-    def to_provider(
-        message_params: list[BaseMessageParam], client: Client | None = None
-    ) -> list[ContentDict]:
-        """
-        Convert from Mirascope `BaseMessageParam` to Google `ContentDict`.
-        """
-        return convert_message_params(
-            cast(list[BaseMessageParam | ContentDict], message_params),
-            client or Client(),
-        )
-
-    @staticmethod
-    def from_provider(message_params: list[ContentOrDict]) -> list[BaseMessageParam]:
-        """
-        Convert from Google's `ContentDict` to Mirascope `BaseMessageParam`.
-        """
-        converted: list[BaseMessageParam] = []
-        for message_param in message_params:
-            if isinstance(message_param, dict):
-                message_param = Content.model_validate(message_param)
-            role = message_param.role
-            if not role or role == "model":
-                role = "assistant"
-            content_list = []
-            for part in message_param.parts or []:
-                if part.text:
-                    content_list.append(TextPart(type="text", text=part.text))
-
-                elif blob := part.inline_data:
-                    mime_type = blob.mime_type or ""
-                    data = blob.data or b""
-                    if mime_type.startswith("image/"):
-                        _check_image_media_type(mime_type)
-                        content_list.append(
-                            ImagePart(
-                                type="image",
-                                media_type=mime_type,
-                                image=data,
-                                detail=None,
-                            )
-                        )
-                    elif mime_type.startswith("audio/"):
-                        _check_audio_media_type(mime_type)
-                        content_list.append(
-                            AudioPart(
-                                type="audio",
-                                media_type=mime_type,
-                                audio=data,
-                            )
-                        )
-                    elif mime_type == "application/pdf":
-                        content_list.append(
-                            DocumentPart(
-                                type="document", media_type=mime_type, document=data
-                            )
-                        )
-                    else:
-                        raise ValueError(
-                            f"Unsupported inline_data mime type: {mime_type}. Cannot convert to BaseMessageParam."
-                        )
-
-                elif file_data := part.file_data:
-                    mime_type = file_data.mime_type or ""
-                    if mime_type.startswith("image/"):
-                        content_list.append(
-                            ImageURLPart(
-                                type="image_url",
-                                url=cast(str, part.file_data.file_uri),
-                                detail=None,
-                            )
-                        )
-                    elif mime_type.startswith("audio/"):
-                        content_list.append(
-                            AudioURLPart(
-                                type="audio_url",
-                                url=cast(str, part.file_data.file_uri),
-                            )
-                        )
-                    else:
-                        # Since `FileDataDict` handles any file data, we use
-                        # `ImageURLPart` for unknown mime types
-                        content_list.append(
-                            ImageURLPart(
-                                type="image_url",
-                                url=cast(str, part.file_data.file_uri),
-                                detail=None,
-                            )
-                        )
-                elif part.function_call:
-                    converted.append(
-                        BaseMessageParam(
-                            role=role,
-                            content=[
-                                ToolCallPart(
-                                    type="tool_call",
-                                    name=part.function_call.name,  # pyright: ignore [reportArgumentType]
-                                    args=part.function_call.args,
-                                )
-                            ],
-                        )
-                    )
-                elif part.function_response:
-                    converted.append(
-                        BaseMessageParam(
-                            role=role,
-                            content=[
-                                ToolResultPart(
-                                    type="tool_result",
-                                    name=part.function_response.name,  # pyright: ignore [reportArgumentType]
-                                    content=part.function_response.response[  # pyright: ignore [reportArgumentType, reportOptionalSubscript]
-                                        "content"
-                                    ],
-                                    id=None,
-                                    is_error=False,
-                                )
-                            ],
-                        )
-                    )
-                else:
-                    raise ValueError(
-                        "Part does not contain any supported content (text, image, or document)."
-                    )
-
-            if len(content_list) == 1 and isinstance(content_list[0], TextPart):
-                converted.append(
-                    BaseMessageParam(role=role, content=content_list[0].text)
-                )
-            else:
-                if content_list:
-                    converted.append(BaseMessageParam(role=role, content=content_list))
-
-        return converted

mirascope/core/google/_utils/_setup_call.py

@@ -1,201 +0,0 @@
-"""This module contains the setup_call function, which is used to set up the"""
-
-import contextlib
-from collections.abc import Awaitable, Callable, Generator
-from typing import Any, cast, overload
-
-from google.genai import Client
-from google.genai.types import (
-    ContentDict,
-    FunctionCallingConfig,
-    FunctionCallingConfigMode,
-    GenerateContentConfig,
-    GenerateContentConfigDict,
-    GenerateContentResponse,
-    Part,
-    PartDict,
-    ToolConfig,
-    ToolListUnion,
-)
-from pydantic import BaseModel
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ...base._utils import (
-    AsyncCreateFn,
-    CreateFn,
-    fn_is_async,
-    get_async_create_fn,
-    get_create_fn,
-)
-from ...base.call_params import CommonCallParams
-from ...base.stream_config import StreamConfig
-from .._call_kwargs import GoogleCallKwargs
-from ..call_params import GoogleCallParams
-from ..dynamic_config import GoogleDynamicConfig
-from ..tool import GoogleTool
-from ._convert_common_call_params import convert_common_call_params
-from ._convert_message_params import convert_message_params
-
-
-def _get_generate_content_config(
-    config: GenerateContentConfig | GenerateContentConfigDict,
-) -> GenerateContentConfig:
-    if isinstance(config, dict):
-        return GenerateContentConfig.model_validate(config)
-    return config
-
-
-@contextlib.contextmanager
-def _generate_content_config_context(
-    call_kwargs: GoogleCallKwargs,
-) -> Generator[GenerateContentConfig, None, None]:
-    config = call_kwargs.get("config", {})
-    config = _get_generate_content_config(config)
-    yield config
-    call_kwargs["config"] = config
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: Client | None,
-    fn: Callable[..., Awaitable[GoogleDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: GoogleDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GoogleCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[GenerateContentResponse, GenerateContentResponse],
-    str | None,
-    list[ContentDict],
-    list[type[GoogleTool]] | None,
-    GoogleCallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: Client | None,
-    fn: Callable[..., GoogleDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: GoogleDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GoogleCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[GenerateContentResponse, GenerateContentResponse],
-    str | None,
-    list[ContentDict],
-    list[type[GoogleTool]] | None,
-    GoogleCallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: Client | None,
-    fn: Callable[..., GoogleDynamicConfig | Awaitable[GoogleDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: GoogleDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GoogleCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[GenerateContentResponse, GenerateContentResponse]
-    | AsyncCreateFn[GenerateContentResponse, GenerateContentResponse],
-    str | None,
-    list[ContentDict],
-    list[type[GoogleTool]] | None,
-    GoogleCallKwargs,
-]:
-    prompt_template, messages, tool_types, base_call_kwargs = _utils.setup_call(
-        fn,
-        fn_args,
-        dynamic_config,
-        tools,
-        GoogleTool,
-        call_params,
-        convert_common_call_params,
-    )
-    call_kwargs = cast(GoogleCallKwargs, base_call_kwargs)
-    messages = cast(list[BaseMessageParam | ContentDict], messages)
-
-    if client is None:
-        client = Client()
-
-    messages = convert_message_params(messages, client)
-
-    if messages[0] and messages[0].get("role") == "system":
-        with _generate_content_config_context(call_kwargs) as config:
-            system_message = messages.pop(0)
-            message_parts = system_message.get("parts", [])
-            if message_parts:
-                config.system_instruction = [
-                    Part.model_validate(part) for part in message_parts
-                ]
-
-    if json_mode:
-        with _generate_content_config_context(call_kwargs) as config:
-            if not tools:
-                config.response_mime_type = "application/json"
-        messages[-1]["parts"].append(  # pyright: ignore [reportTypedDictNotRequiredAccess, reportOptionalMemberAccess, reportArgumentType]
-            PartDict(text=_utils.json_mode_content(response_model))
-        )  # pyright: ignore [reportTypedDictNotRequiredAccess, reportOptionalMemberAccess, reportArgumentType]
-    elif response_model:
-        assert tool_types, "At least one tool must be provided for extraction."
-        with _generate_content_config_context(call_kwargs) as config:
-            config.tool_config = ToolConfig(
-                function_calling_config=FunctionCallingConfig(
-                    mode=FunctionCallingConfigMode.ANY,
-                    allowed_function_names=[tool_types[0]._name()],
-                )
-            )
-    config_tools = call_kwargs.pop("tools", None)
-    if config_tools:
-        with _generate_content_config_context(call_kwargs) as config:
-            config.tools = cast(ToolListUnion, config_tools)
-
-    call_kwargs |= {"model": model, "contents": messages}
-
-    create = (
-        get_async_create_fn(
-            client.aio.models.generate_content,
-            client.aio.models.generate_content_stream,
-        )
-        if fn_is_async(fn)
-        else get_create_fn(
-            client.models.generate_content, client.models.generate_content_stream
-        )
-    )
-    if client.vertexai:
-        if isinstance(dynamic_config, dict):
-            metadata = dynamic_config.get("metadata", {})
-            tags = metadata.get("tags", set())
-            tags.add("use_vertex_ai")
-            metadata["tags"] = tags
-            dynamic_config["metadata"] = metadata
-        else:
-            metadata = getattr(fn, "_metadata", {})
-            tags = metadata.get("tags", set())
-            tags.add("use_vertex_ai")
-            metadata["tags"] = tags
-            fn._metadata = metadata
-
-    return (
-        create,
-        prompt_template,
-        messages,
-        tool_types,
-        call_kwargs,
-    )

mirascope/core/google/_utils/_validate_media_type.py

@@ -1,34 +0,0 @@
-"""Utilities for validating supported media types for Google models."""
-
-
-def _check_image_media_type(media_type: str) -> None:
-    """Raises a `ValueError` if the image media type is not supported."""
-    if media_type not in [
-        "image/jpeg",
-        "image/png",
-        "image/webp",
-        "image/heic",
-        "image/heif",
-    ]:
-        raise ValueError(
-            f"Unsupported image media type: {media_type}. "
-            "Google currently only supports JPEG, PNG, WebP, HEIC, "
-            "and HEIF images."
-        )
-
-
-def _check_audio_media_type(media_type: str) -> None:
-    """Raises a `ValueError` if the audio media type is not supported."""
-    if media_type not in [
-        "audio/wav",
-        "audio/mp3",
-        "audio/aiff",
-        "audio/aac",
-        "audio/ogg",
-        "audio/flac",
-    ]:
-        raise ValueError(
-            f"Unsupported audio media type: {media_type}. "
-            "Google currently only supports WAV, MP3, AIFF, AAC, OGG, "
-            "and FLAC audio file types."
-        )

mirascope/core/google/call_params.py

@@ -1,22 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from google.genai.types import (
-    GenerateContentConfigOrDict,
-)
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-
-class GoogleCallParams(BaseCallParams):
-    """The parameters to use when calling the Google API.
-
-    [Google API Reference](https://ai.google.dev/google-api/docs/text-generation?lang=python)
-
-    Attributes:
-        config: ...
-    """
-
-    config: NotRequired[GenerateContentConfigOrDict]

mirascope/core/google/call_response.py

@@ -1,232 +0,0 @@
-"""This module contains the `GoogleCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-
-from google.genai.types import (
-    ContentDict,
-    ContentListUnion,
-    ContentListUnionDict,
-    FunctionResponseDict,
-    GenerateContentResponse,
-    GenerateContentResponseUsageMetadata,
-    PartDict,
-    # Import manually SchemaDict to avoid Pydantic error
-    SchemaDict,  # noqa: F401
-    Tool,
-)
-from pydantic import computed_field
-
-from .. import BaseMessageParam
-from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import CostMetadata, FinishReason, GoogleMetadata
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-from ._utils._message_param_converter import GoogleMessageParamConverter
-from .call_params import GoogleCallParams
-from .dynamic_config import GoogleDynamicConfig
-from .tool import GoogleTool
-
-
-class GoogleCallResponse(
-    BaseCallResponse[
-        GenerateContentResponse,
-        GoogleTool,
-        Tool,
-        GoogleDynamicConfig,
-        ContentListUnion | ContentListUnionDict,
-        GoogleCallParams,
-        ContentDict,
-        GoogleMessageParamConverter,
-    ]
-):
-    """A convenience wrapper around the Google API response.
-
-    When calling the Google API using a function decorated with `google_call`, the
-    response will be a `GoogleCallResponse` instance with properties that allow for
-    more convenient access to commonly used attributes.
-
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.google import google_call
-
-
-    @google_call("google-1.5-flash")
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")  # response is an `GoogleCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _message_converter: type[GoogleMessageParamConverter] = GoogleMessageParamConverter
-
-    _provider = "google"
-
-    @computed_field
-    @property
-    def content(self) -> str:
-        """Returns the contained string content for the 0th choice."""
-        return self.response.candidates[0].content.parts[0].text  # pyright: ignore [reportOptionalSubscript, reportReturnType, reportOptionalMemberAccess, reportOptionalIterable]
-
-    @computed_field
-    @property
-    def finish_reasons(self) -> list[str]:
-        """Returns the finish reasons of the response."""
-
-        return [
-            candidate.finish_reason.value
-            for candidate in (self.response.candidates or [])
-            if candidate and candidate.finish_reason is not None
-        ]
-
-    @computed_field
-    @property
-    def model(self) -> str:
-        """Returns the model name.
-
-        google.generativeai does not return model, so we return the model provided by
-        the user.
-        """
-        return (
-            self.response.model_version if self.response.model_version else self._model
-        )
-
-    @computed_field
-    @property
-    def id(self) -> str | None:
-        """Returns the id of the response.
-
-        google.generativeai does not return an id
-        """
-        return None
-
-    @property
-    def usage(self) -> GenerateContentResponseUsageMetadata | None:
-        """Returns the usage of the chat completion.
-
-        google.generativeai does not have Usage, so we return None
-        """
-        return self.response.usage_metadata
-
-    @computed_field
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        return (
-            self.response.usage_metadata.prompt_token_count
-            if self.response.usage_metadata
-            else None
-        )
-
-    @computed_field
-    @property
-    def cached_tokens(self) -> int | None:
-        """Returns the number of cached tokens."""
-        return (
-            self.response.usage_metadata.cached_content_token_count
-            if self.response.usage_metadata
-            else None
-        )
-
-    @computed_field
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        return (
-            self.response.usage_metadata.candidates_token_count
-            if self.response.usage_metadata
-            else None
-        )
-
-    @computed_field
-    @cached_property
-    def message_param(self) -> ContentDict:
-        """Returns the models's response as a message parameter."""
-        return {"role": "model", "parts": self.response.candidates[0].content.parts}  # pyright: ignore [reportReturnType, reportOptionalSubscript, reportOptionalMemberAccess]
-
-    @cached_property
-    def tools(self) -> list[GoogleTool] | None:
-        """Returns the list of tools for the response."""
-        if self.tool_types is None:
-            return None
-
-        extracted_tools = []
-        for tool_call in self.response.function_calls or []:
-            for tool_type in self.tool_types:
-                if tool_call.name == tool_type._name():  # pyright: ignore [reportOptionalMemberAccess]
-                    extracted_tools.append(tool_type.from_tool_call(tool_call))  # pyright: ignore [reportArgumentType]
-                    break
-
-        return extracted_tools
-
-    @cached_property
-    def tool(self) -> GoogleTool | None:
-        """Returns the 0th tool for the 0th candidate's 0th content part.
-
-        Raises:
-            ValidationError: if the tool call doesn't match the tool's schema.
-        """
-        tools = self.tools
-        if tools:
-            return tools[0]
-        return None
-
-    @classmethod
-    @transform_tool_outputs
-    def tool_message_params(
-        cls, tools_and_outputs: Sequence[tuple[GoogleTool, str]]
-    ) -> list[ContentDict]:
-        """Returns the tool message parameters for tool call results.
-
-        Args:
-            tools_and_outputs: The sequence of tools and their outputs from which the tool
-                message parameters should be constructed.
-
-        Returns:
-            The list of constructed `FunctionResponse` parameters.
-        """
-        return [
-            {
-                "role": "user",
-                "parts": [
-                    PartDict(
-                        function_response=FunctionResponseDict(
-                            name=tool._name(), response={"result": output}
-                        )
-                    )
-                    for tool, output in tools_and_outputs
-                ],
-            }
-        ]
-
-    @property
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
-
-    @property
-    def common_message_param(self) -> BaseMessageParam:
-        return GoogleMessageParamConverter.from_provider([self.message_param])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return GoogleMessageParamConverter.from_provider([self.user_message_param])[0]
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        cost_metadata = super().cost_metadata
-        cost_metadata.google = GoogleMetadata(
-            use_vertex_ai="use_vertex_ai" in self.metadata.get("tags", [])
-        )
-        return cost_metadata