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

mirascope/core/gemini/__init__.py

@@ -1,40 +0,0 @@
-"""The Mirascope Gemini Module."""
-
-import inspect
-import warnings
-from typing import TypeAlias
-
-from google.generativeai.protos import FunctionResponse
-from google.generativeai.types import ContentDict
-
-from ..base import BaseMessageParam
-from ._call import gemini_call
-from ._call import gemini_call as call
-from .call_params import GeminiCallParams
-from .call_response import GeminiCallResponse
-from .call_response_chunk import GeminiCallResponseChunk
-from .dynamic_config import GeminiDynamicConfig
-from .stream import GeminiStream
-from .tool import GeminiTool
-
-GeminiMessageParam: TypeAlias = ContentDict | 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.
-    """),
-    category=DeprecationWarning,
-)
-
-__all__ = [
-    "GeminiCallParams",
-    "GeminiCallResponse",
-    "GeminiCallResponseChunk",
-    "GeminiDynamicConfig",
-    "GeminiMessageParam",
-    "GeminiStream",
-    "GeminiTool",
-    "call",
-    "gemini_call",
-]

mirascope/core/gemini/_call.py

@@ -1,67 +0,0 @@
-"""The `gemini_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 GeminiCallParams
-from .call_response import GeminiCallResponse
-from .call_response_chunk import GeminiCallResponseChunk
-from .stream import GeminiStream
-from .tool import GeminiTool
-
-gemini_call = call_factory(
-    TCallResponse=GeminiCallResponse,
-    TCallResponseChunk=GeminiCallResponseChunk,
-    TStream=GeminiStream,
-    TToolType=GeminiTool,
-    default_call_params=GeminiCallParams(),
-    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 Gemini API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Gemini 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.gemini import gemini_call
-
-
-@gemini_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 Gemini 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 Gemini API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[GeminiCallResponse | 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 (GeminiCallParams): The `GeminiCallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a Gemini API
-        call.
-"""

mirascope/core/gemini/_call_kwargs.py

@@ -1,12 +0,0 @@
-"""This module contains the type definition for the Gemini call keyword arguments."""
-
-from collections.abc import Sequence
-
-from google.generativeai.types import ContentDict, Tool
-
-from ..base import BaseCallKwargs
-from .call_params import GeminiCallParams
-
-
-class GeminiCallKwargs(GeminiCallParams, BaseCallKwargs[Tool]):
-    contents: Sequence[ContentDict]

mirascope/core/gemini/_utils/__init__.py

@@ -1,14 +0,0 @@
-"""Gemini 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/gemini/_utils/_convert_common_call_params.py

@@ -1,39 +0,0 @@
-from typing import cast
-
-from google.generativeai.types import (
-    GenerationConfigDict,
-)
-
-from ...base.call_params import CommonCallParams
-from ..call_params import GeminiCallParams
-
-GEMINI_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "max_output_tokens",
-    "top_p": "top_p",
-    "stop": "stop_sequences",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> GeminiCallParams:
-    """Convert CommonCallParams to Gemini parameters."""
-    generation_config = {}
-
-    for key, value in common_params.items():
-        if key not in GEMINI_PARAM_MAPPING or value is None:
-            continue
-
-        if key == "stop":
-            generation_config["stop_sequences"] = (
-                [value] if isinstance(value, str) else value
-            )
-        else:
-            generation_config[GEMINI_PARAM_MAPPING[key]] = value
-
-    if not generation_config:
-        return cast(GeminiCallParams, {})
-
-    return cast(
-        GeminiCallParams,
-        {"generation_config": cast(GenerationConfigDict, generation_config)},
-    )

mirascope/core/gemini/_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/gemini/_utils/_convert_message_params.py

@@ -1,156 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ContentsType`"""
-
-import io
-
-import PIL.Image
-from google.generativeai import protos
-from google.generativeai.types import ContentDict
-
-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 | ContentDict],
-) -> list[ContentDict]:
-    converted_message_params = []
-    for message_param in message_params:
-        if not isinstance(message_param, BaseMessageParam):
-            converted_message_params.append(message_param)
-        elif (role := message_param.role) == "system":
-            if not isinstance(message_param.content, str):
-                raise ValueError(
-                    "System message content must be a single text string."
-                )  # pragma: no cover
-            converted_message_params += [
-                {
-                    "role": "system",
-                    "parts": [message_param.content],
-                },
-            ]
-        elif isinstance((content := message_param.content), str):
-            converted_message_params.append(
-                {"role": role if role == "user" else "model", "parts": [content]}
-            )
-        else:
-            converted_content = []
-            for part in content:
-                if part.type == "text":
-                    converted_content.append(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}. "
-                            "Gemini currently only supports JPEG, PNG, WebP, HEIC, "
-                            "and HEIF images."
-                        )
-                    image = PIL.Image.open(io.BytesIO(part.image))
-                    converted_content.append(image)
-                elif part.type == "image_url":
-                    if part.url.startswith(("https://", "http://")):
-                        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(image)
-                    else:
-                        converted_content.append(protos.FileData(file_uri=part.url))
-                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}. "
-                            "Gemini currently only supports WAV, MP3, AIFF, AAC, OGG, "
-                            "and FLAC audio file types."
-                        )
-                    converted_content.append(
-                        {"mime_type": part.media_type, "data": part.audio}
-                    )
-                elif part.type == "audio_url":
-                    if part.url.startswith(("https://", "http://")):
-                        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(
-                            {"mime_type": audio_type, "data": audio}
-                        )
-                    else:
-                        converted_content.append(protos.FileData(file_uri=part.url))
-                elif part.type == "tool_call":
-                    converted_content.append(
-                        protos.FunctionCall(
-                            name=part.name,
-                            args=part.args,
-                        )
-                    )
-                elif part.type == "tool_result":
-                    if converted_content:
-                        converted_message_params.append(
-                            {
-                                "role": role if role == "user" else "model",
-                                "parts": converted_content,
-                            }
-                        )
-                        converted_content = []
-                    converted_message_params.append(
-                        {
-                            "role": "user",
-                            "parts": [
-                                protos.FunctionResponse(
-                                    name=part.name, response={"result": part.content}
-                                )
-                            ],
-                        }
-                    )
-                else:
-                    raise ValueError(
-                        "Gemini currently only supports text, image, and audio parts. "
-                        f"Part provided: {part.type}"
-                    )
-            if converted_content:
-                converted_message_params.append(
-                    {
-                        "role": role if role == "user" else "model",
-                        "parts": converted_content,
-                    }
-                )
-    return converted_message_params

mirascope/core/gemini/_utils/_get_json_output.py

@@ -1,35 +0,0 @@
-"""Get JSON output from a Gemini response."""
-
-import json
-
-from proto.marshal.collections import RepeatedComposite
-
-from ..call_response import GeminiCallResponse
-from ..call_response_chunk import GeminiCallResponseChunk
-
-
-def get_json_output(
-    response: GeminiCallResponse | GeminiCallResponseChunk, json_mode: bool
-) -> str:
-    """Extracts the JSON output from a Gemini response."""
-    if isinstance(response, GeminiCallResponse):
-        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 part in response.response.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("Gemini only supports structured streaming in json mode.")
-    return response.content

mirascope/core/gemini/_utils/_handle_stream.py

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

mirascope/core/gemini/_utils/_message_param_converter.py

@@ -1,209 +0,0 @@
-# file: gemini_message_param_converter.py
-
-from typing import cast
-
-from google.generativeai.types import (
-    ContentDict,
-    protos,
-)
-
-from mirascope.core import BaseMessageParam
-from mirascope.core.base import (
-    AudioPart,
-    AudioURLPart,
-    DocumentPart,
-    ImagePart,
-    ImageURLPart,
-    TextPart,
-)
-from mirascope.core.base._utils._base_message_param_converter import (
-    BaseMessageParamConverter,
-)
-from mirascope.core.base.message_param import ToolCallPart, ToolResultPart
-from mirascope.core.gemini._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 _is_audio_mime(mime_type: str) -> bool:
-    return mime_type in [
-        "audio/wav",
-        "audio/mp3",
-        "audio/wav",
-        "audio/mp3",
-        "audio/aiff",
-        "audio/aac",
-        "audio/ogg",
-        "audio/flac",
-    ]
-
-
-def _to_audio_part(mime_type: str, data: bytes) -> AudioPart:
-    if not _is_audio_mime(mime_type):
-        raise ValueError(
-            f"Unsupported audio media type: {mime_type}. "
-            "Expected one of: audio/wav, audio/mp3, audio/aiff, audio/aac, audio/ogg, audio/flac."
-        )
-    return AudioPart(type="audio", media_type=mime_type, audio=data)
-
-
-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 GeminiMessageParamConverter(BaseMessageParamConverter):
-    """Converts between Gemini `ContentDict` and Mirascope `BaseMessageParam`."""
-
-    @staticmethod
-    def to_provider(message_params: list[BaseMessageParam]) -> list[ContentDict]:
-        """
-        Convert from Mirascope `BaseMessageParam` to Gemini `ContentDict`.
-        """
-        return convert_message_params(
-            cast(list[BaseMessageParam | ContentDict], message_params)
-        )
-
-    @staticmethod
-    def from_provider(message_params: list[ContentDict]) -> list[BaseMessageParam]:
-        """
-        Convert from Gemini's `ContentDict` to Mirascope `BaseMessageParam`.
-        """
-        converted: list[BaseMessageParam] = []
-        for message_param in message_params:
-            role: str = (
-                "assistant"
-                if message_param["role"] == "model"
-                else message_param["role"]
-            )
-            content_list = []
-            for part in cast(
-                list[protos.Part | protos.FunctionCall | protos.FunctionResponse],
-                message_param["parts"],
-            ):
-                if isinstance(part, protos.Part):
-                    if part.text:
-                        content_list.append(TextPart(type="text", text=part.text))
-
-                    elif part.inline_data:
-                        blob = part.inline_data
-                        mime = blob.mime_type
-                        data = blob.data
-                        if _is_image_mime(mime):
-                            content_list.append(_to_image_part(mime, data))
-                        elif _is_audio_mime(mime):
-                            content_list.append(_to_audio_part(mime, data))
-                        elif mime == "application/pdf":
-                            content_list.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):
-                            content_list.append(
-                                ImageURLPart(
-                                    type="image_url",
-                                    url=part.file_data.file_uri,
-                                    detail=None,
-                                )
-                            )
-                        elif _is_audio_mime(part.file_data.mime_type):
-                            content_list.append(
-                                AudioURLPart(
-                                    type="audio_url",
-                                    url=part.file_data.file_uri,
-                                )
-                            )
-                        else:
-                            raise ValueError(
-                                f"Unsupported file_data mime type: {part.file_data.mime_type}. 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.function_response:
-                        converted.append(
-                            BaseMessageParam(
-                                role=role,
-                                content=[
-                                    ToolResultPart(
-                                        type="tool_result",
-                                        name=part.function_response.name,
-                                        content=part.function_response.response[  # pyright: ignore [reportArgumentType]
-                                            "result"
-                                        ],
-                                        id=None,
-                                        is_error=False,
-                                    )
-                                ],
-                            )
-                        )
-                    else:
-                        raise ValueError(
-                            "Part does not contain any supported content (text, image, or document)."
-                        )
-                elif isinstance(part, protos.FunctionCall):
-                    converted.append(
-                        BaseMessageParam(
-                            role=role,
-                            content=[
-                                ToolCallPart(
-                                    type="tool_call",
-                                    name=part.name,
-                                    args=dict(part.args),
-                                )
-                            ],
-                        )
-                    )
-                elif isinstance(part, protos.FunctionResponse):
-                    converted.append(
-                        BaseMessageParam(
-                            role=role,
-                            content=[
-                                ToolResultPart(
-                                    type="tool_result",
-                                    name=part.name,
-                                    content=part.response["result"],  # pyright: ignore [reportArgumentType]
-                                    id=None,
-                                    is_error=False,
-                                )
-                            ],
-                        )
-                    )
-
-            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