mirascope 1.25.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

mirascope/core/gemini/tool.py

@@ -1,104 +0,0 @@
-"""The `GeminiTool` class for easy tool usage with Google's Gemini LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from google.ai.generativelanguage import FunctionCall
-from google.generativeai.types import (
-    FunctionDeclaration,
-    Tool,
-)
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool
-
-
-class GeminiTool(BaseTool):
-    """A class for defining tools for Gemini LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.gemini import gemini_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @gemini_call("gemini-1.5-flash", 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 `GeminiTool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "gemini"
-
-    tool_call: SkipJsonSchema[FunctionCall]
-
-    @classmethod
-    def tool_schema(cls) -> Tool:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.gemini import GeminiTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = GeminiTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Gemini-specific tool schema
-        ```
-        """
-        model_schema = cls.model_json_schema()
-        fn: dict[str, Any] = {"name": cls._name(), "description": cls._description()}
-
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema
-
-        if "parameters" in fn:
-            if "$defs" in fn["parameters"]:
-                raise ValueError(
-                    "Unfortunately Google's Gemini API cannot handle nested structures "
-                    "with $defs."
-                )
-
-            def handle_enum_schema(prop_schema: dict[str, Any]) -> dict[str, Any]:
-                if "enum" in prop_schema:
-                    prop_schema["format"] = "enum"
-                return prop_schema
-
-            fn["parameters"]["properties"] = {
-                prop: {
-                    key: value
-                    for key, value in handle_enum_schema(prop_schema).items()
-                    if key != "default"
-                }
-                for prop, prop_schema in fn["parameters"]["properties"].items()
-            }
-        return Tool(function_declarations=[FunctionDeclaration(**fn)])
-
-    @classmethod
-    def from_tool_call(cls, tool_call: FunctionCall) -> GeminiTool:
-        """Constructs an `GeminiTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Gemini tool call from which to construct this tool instance.
-        """
-        model_json = {"tool_call": tool_call}
-        if tool_call.args:
-            model_json |= dict(tool_call.args.items())
-        return cls.model_validate(model_json)

mirascope/core/google/__init__.py

@@ -1,29 +0,0 @@
-"""The Mirascope Google Module."""
-
-from typing import TypeAlias
-
-from google.genai.types import ContentDict, FunctionResponse
-
-from ..base import BaseMessageParam
-from ._call import google_call
-from ._call import google_call as call
-from .call_params import GoogleCallParams
-from .call_response import GoogleCallResponse
-from .call_response_chunk import GoogleCallResponseChunk
-from .dynamic_config import GoogleDynamicConfig
-from .stream import GoogleStream
-from .tool import GoogleTool
-
-GoogleMessageParam: TypeAlias = ContentDict | FunctionResponse | BaseMessageParam
-
-__all__ = [
-    "GoogleCallParams",
-    "GoogleCallResponse",
-    "GoogleCallResponseChunk",
-    "GoogleDynamicConfig",
-    "GoogleMessageParam",
-    "GoogleStream",
-    "GoogleTool",
-    "call",
-    "google_call",
-]

mirascope/core/google/_call.py

@@ -1,67 +0,0 @@
-"""The `google_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 GoogleCallParams
-from .call_response import GoogleCallResponse
-from .call_response_chunk import GoogleCallResponseChunk
-from .stream import GoogleStream
-from .tool import GoogleTool
-
-google_call = call_factory(
-    TCallResponse=GoogleCallResponse,
-    TCallResponseChunk=GoogleCallResponseChunk,
-    TStream=GoogleStream,
-    TToolType=GoogleTool,
-    default_call_params=GoogleCallParams(),
-    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 Google API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Google 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.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")
-print(response.content)
-```
-
-Args:
-    model (str): The Google 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 Google API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[GoogleCallResponse | 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 (GoogleCallParams): The `GoogleCallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a Google API
-        call.
-"""

mirascope/core/google/_call_kwargs.py

@@ -1,13 +0,0 @@
-"""This module contains the type definition for the Google call keyword arguments."""
-
-from collections.abc import Sequence
-
-from google.genai.types import ContentOrDict, Tool
-
-from ..base import BaseCallKwargs
-from .call_params import GoogleCallParams
-
-
-class GoogleCallKwargs(GoogleCallParams, BaseCallKwargs[Tool]):
-    model: str
-    contents: Sequence[ContentOrDict]

mirascope/core/google/_utils/__init__.py

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

@@ -1,38 +0,0 @@
-from typing import cast
-
-from google.genai.types import GenerateContentConfig
-
-from ...base.call_params import CommonCallParams
-from ..call_params import GoogleCallParams
-
-GOOGLE_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "max_output_tokens",
-    "top_p": "top_p",
-    "stop": "stop_sequences",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> GoogleCallParams:
-    """Convert CommonCallParams to Google parameters."""
-    config = GenerateContentConfig()
-
-    for key, value in common_params.items():
-        if key not in GOOGLE_PARAM_MAPPING or value is None:
-            continue
-
-        if key == "stop":
-            # Google API expects a list of strings for stop sequences
-            if isinstance(value, str):
-                config.stop_sequences = [value]
-            elif isinstance(value, list):
-                config.stop_sequences = value
-        else:
-            target_attr = GOOGLE_PARAM_MAPPING[key]
-            setattr(config, target_attr, value)
-
-    default_config = GenerateContentConfig()
-    if config == default_config:
-        return cast(GoogleCallParams, {})
-
-    return cast(GoogleCallParams, {"config": config})

mirascope/core/google/_utils/_convert_finish_reason_to_common_finish_reasons.py

@@ -1,27 +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",
-    "BLOCKLIST": "stop",
-    "PROHIBITED_CONTENT": "stop",
-    "SPII": "stop",
-    "MALFORMED_FUNCTION_CALL": "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/google/_utils/_convert_message_params.py

@@ -1,297 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ContentsType`"""
-
-import asyncio
-import base64
-import io
-from concurrent.futures import ThreadPoolExecutor
-
-from google.genai import Client
-from google.genai.types import (
-    BlobDict,
-    ContentDict,
-    FileDataDict,
-    FunctionCallDict,
-    FunctionResponseDict,
-    PartDict,
-)
-
-from ...base import BaseMessageParam
-from ...base._utils import get_audio_type, get_document_type, get_image_type
-from ...base._utils._parse_content_template import _load_media
-from ._validate_media_type import (
-    _check_audio_media_type,
-    _check_document_media_type,
-    _check_image_media_type,
-)
-
-
-def _over_file_size_limit(size: int) -> bool:
-    """Check if the total file size exceeds the limit (10mb).
-
-    Google limit is 20MB but base64 adds 33% to the size.
-    """
-    return size > 10 * 1024 * 1024  # 10MB
-
-
-async def _convert_message_params_async(
-    message_params: list[BaseMessageParam | ContentDict], client: Client
-) -> list[ContentDict]:
-    converted_message_params = []
-    total_payload_size = 0
-    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": [PartDict(text=message_param.content)],
-                }
-            ]
-        elif isinstance((content := message_param.content), str):
-            converted_message_params.append(
-                {
-                    "role": role if role == "user" else "model",
-                    "parts": [PartDict(text=content)],
-                }
-            )
-        else:
-            converted_content = []
-            must_upload: dict[int, BlobDict] = {}
-            for index, part in enumerate(content):
-                if part.type == "text":
-                    converted_content.append(PartDict(text=part.text))
-                elif part.type == "tool_call":
-                    converted_content.append(
-                        PartDict(
-                            function_call=FunctionCallDict(
-                                name=part.name, args=part.args, id=part.id
-                            )
-                        )
-                    )
-                elif part.type == "tool_result":
-                    converted_content.append(
-                        PartDict(
-                            function_response=FunctionResponseDict(
-                                name=part.name,
-                                response={"content": part.content},
-                                id=part.id,
-                            )
-                        )
-                    )
-                elif part.type == "image":
-                    _check_image_media_type(part.media_type)
-                    blob_dict = BlobDict(data=part.image, mime_type=part.media_type)
-                    converted_content.append(PartDict(inline_data=blob_dict))
-                    image_size = len(part.image)
-                    total_payload_size += image_size
-                    if (
-                        _over_file_size_limit(total_payload_size)
-                        and not client.vertexai
-                    ):
-                        must_upload[index] = blob_dict
-                        total_payload_size -= image_size
-                elif part.type == "image_url":
-                    if (
-                        client.vertexai
-                        or not part.url.startswith(("https://", "http://"))
-                        or "generativelanguage.googleapis.com" in part.url
-                    ):
-                        converted_content.append(
-                            PartDict(
-                                file_data=FileDataDict(
-                                    file_uri=part.url, mime_type=None
-                                )
-                            )
-                        )
-                    else:
-                        downloaded_image = _load_media(part.url)
-                        media_type = f"image/{get_image_type(downloaded_image)}"
-                        _check_image_media_type(media_type)
-                        blob_dict = BlobDict(
-                            data=downloaded_image, mime_type=media_type
-                        )
-                        converted_content.append(PartDict(inline_data=blob_dict))
-                        image_size = len(downloaded_image)
-                        total_payload_size += image_size
-                        if (
-                            _over_file_size_limit(total_payload_size)
-                            and not client.vertexai
-                        ):
-                            must_upload[index] = blob_dict
-                            total_payload_size -= image_size
-                elif part.type == "audio":
-                    _check_audio_media_type(part.media_type)
-                    audio_data = (
-                        part.audio
-                        if isinstance(part.audio, bytes)
-                        else base64.b64decode(part.audio)
-                    )
-                    blob_dict = BlobDict(data=audio_data, mime_type=part.media_type)
-                    converted_content.append(PartDict(inline_data=blob_dict))
-                    audio_size = len(audio_data)
-                    total_payload_size += audio_size
-                    if (
-                        _over_file_size_limit(total_payload_size)
-                        and not client.vertexai
-                    ):
-                        must_upload[index] = blob_dict
-                        total_payload_size -= audio_size
-                elif part.type == "audio_url":
-                    if (
-                        client.vertexai
-                        or not part.url.startswith(("https://", "http://"))
-                        or "generativelanguage.googleapis.com" in part.url
-                    ):
-                        converted_content.append(
-                            PartDict(
-                                file_data=FileDataDict(
-                                    file_uri=part.url, mime_type=None
-                                )
-                            )
-                        )
-                    else:
-                        downloaded_audio = _load_media(part.url)
-                        media_type = f"audio/{get_audio_type(downloaded_audio)}"
-                        _check_audio_media_type(media_type)
-                        blob_dict = BlobDict(
-                            data=downloaded_audio, mime_type=media_type
-                        )
-                        converted_content.append(PartDict(inline_data=blob_dict))
-                        audio_size = len(downloaded_audio)
-                        total_payload_size += audio_size
-                        if (
-                            _over_file_size_limit(total_payload_size)
-                            and not client.vertexai
-                        ):
-                            must_upload[index] = blob_dict
-                            total_payload_size -= audio_size
-                elif part.type == "document":
-                    _check_document_media_type(part.media_type)
-                    blob_dict = BlobDict(data=part.document, mime_type=part.media_type)
-                    converted_content.append(PartDict(inline_data=blob_dict))
-                    document_size = len(part.document)
-                    total_payload_size += document_size
-                    if (
-                        _over_file_size_limit(total_payload_size)
-                        and not client.vertexai
-                    ):
-                        must_upload[index] = blob_dict
-                        total_payload_size -= document_size
-                elif part.type == "document_url":
-                    if (
-                        client.vertexai
-                        or not part.url.startswith(("https://", "http://"))
-                        or "generativelanguage.googleapis.com" in part.url
-                    ):
-                        converted_content.append(
-                            PartDict(
-                                file_data=FileDataDict(
-                                    file_uri=part.url, mime_type=None
-                                )
-                            )
-                        )
-                    else:
-                        media_type = None
-                        try:
-                            downloaded_document = _load_media(part.url)
-                            document_types = {
-                                "pdf": "application/pdf",
-                                "html": "text/html",
-                                "xml": "text/xml",
-                                "rtf": "text/rtf",
-                            }
-
-                            try:
-                                document_type_ext = get_document_type(
-                                    downloaded_document
-                                )
-                                media_type = document_types.get(document_type_ext)
-                            except ValueError:
-                                try:
-                                    downloaded_document.decode("utf-8")
-                                    media_type = "text/plain"
-                                except UnicodeDecodeError:
-                                    pass
-
-                            if media_type is None:
-                                raise ValueError(
-                                    f"Unsupported document format detected for URL: {part.url}. "
-                                    "Google API only supports the following document formats: "
-                                    "PDF, JavaScript, Python, TXT, HTML, CSS, Markdown, CSV, XML and RTF. "
-                                    "Please provide a document in one of these supported formats."
-                                )
-
-                            _check_document_media_type(media_type)
-                            blob_dict = BlobDict(
-                                data=downloaded_document, mime_type=media_type
-                            )
-                            converted_content.append(PartDict(inline_data=blob_dict))
-                            document_size = len(downloaded_document)
-                            total_payload_size += document_size
-                            if (
-                                _over_file_size_limit(total_payload_size)
-                                and not client.vertexai
-                            ):
-                                must_upload[index] = blob_dict
-                                total_payload_size -= document_size
-                        except ValueError as e:
-                            raise ValueError(
-                                f"Failed to process document from URL: {part.url}. "
-                                f"Error details: {str(e)}. "
-                                "Please ensure the URL is accessible and points to a supported document format."
-                            )
-                else:
-                    raise ValueError(
-                        "Google currently only supports text, tool_call, tool_result, image, audio, and document parts. "
-                        f"Part provided: {part.type}"
-                    )
-
-            if must_upload and not client.vertexai:
-                indices, blob_dicts = zip(*must_upload.items(), strict=True)
-                upload_tasks = [
-                    client.aio.files.upload(
-                        file=io.BytesIO(blob_dict["data"]),
-                        config={"mime_type": blob_dict.get("mime_type", None)},
-                    )
-                    for blob_dict in blob_dicts
-                ]
-                file_refs = await asyncio.gather(*upload_tasks)
-                for index, file_ref in zip(indices, file_refs, strict=True):
-                    converted_content[index] = PartDict(
-                        file_data=FileDataDict(
-                            file_uri=file_ref.uri, mime_type=file_ref.mime_type
-                        )
-                    )
-
-            converted_message_params.append(
-                {
-                    "role": role if role == "user" else "model",
-                    "parts": converted_content,
-                }
-            )
-    return converted_message_params
-
-
-def convert_message_params(
-    message_params: list[BaseMessageParam | ContentDict], client: Client
-) -> list[ContentDict]:
-    """Convert message params to Google's ContentDict format.
-
-    If called from sync context, uses asyncio.run().
-    If called from async context, uses the current event loop.
-    """
-    try:
-        asyncio.get_running_loop()
-        with ThreadPoolExecutor(max_workers=1) as executor:
-            future = executor.submit(
-                asyncio.run, _convert_message_params_async(message_params, client)
-            )
-            return future.result()
-    except RuntimeError:
-        ...
-    return asyncio.run(_convert_message_params_async(message_params, client))

mirascope/core/google/_utils/_get_json_output.py

@@ -1,37 +0,0 @@
-"""Get JSON output from a Google response."""
-
-import json
-
-from proto.marshal.collections import RepeatedComposite
-
-from ..call_response import GoogleCallResponse
-from ..call_response_chunk import GoogleCallResponseChunk
-
-
-def get_json_output(
-    response: GoogleCallResponse | GoogleCallResponseChunk, json_mode: bool
-) -> str:
-    """Extracts the JSON output from a Google response."""
-    if isinstance(response, GoogleCallResponse):
-        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 := [
-            function_call
-            for function_call in (response.response.function_calls or [])  # pyright: ignore [reportOptionalSubscript, reportOptionalIterable, reportOptionalMemberAccess]
-            if function_call.args  # pyright: ignore [reportOptionalSubscript, reportOptionalIterable, reportOptionalMemberAccess]
-        ]:
-            return json.dumps(
-                {
-                    k: v if not isinstance(v, RepeatedComposite) else list(v)
-                    for k, v in (tool_calls[0].args or {}).items()  # pyright: ignore [reportOptionalMemberAccess]
-                }
-                if isinstance(tool_calls, list) and tool_calls[0]
-                else {}
-            )
-        else:
-            raise ValueError("No tool call or JSON object found in response.")
-    elif not json_mode:
-        raise ValueError("Google only supports structured streaming in json mode.")
-    return response.content