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

mirascope/core/google/_utils/_handle_stream.py

@@ -1,58 +0,0 @@
-"""Handles streaming content and tools from the Google API."""
-
-from collections.abc import AsyncGenerator, Generator
-
-from google.genai.types import GenerateContentResponse
-
-from ..call_response_chunk import GoogleCallResponseChunk
-from ..tool import GoogleTool
-
-
-def _handle_chunk(
-    chunk: GenerateContentResponse, tool_types: list[type[GoogleTool]] | None = None
-) -> Generator[tuple[GoogleCallResponseChunk, GoogleTool | None], None, None]:
-    """Handles a chunk of the stream and yields any tools that are found.
-
-    Note: google seems to only ever return full tool calls, so no partial possible here.
-    """
-    call_response_chunk = GoogleCallResponseChunk(chunk=chunk)
-    has_tools = False
-    if tool_types and (
-        (candidates := chunk.candidates)
-        and (content := candidates[0].content)
-        and (parts := content.parts)
-    ):
-        for part in parts:
-            if function_call := part.function_call:
-                has_tools = True
-                for tool_type in tool_types:
-                    if tool_type._name() == function_call.name:
-                        tool = tool_type.from_tool_call(function_call)
-                        yield (call_response_chunk, tool)
-    if not has_tools:
-        yield call_response_chunk, None
-
-
-def handle_stream(
-    stream: Generator[GenerateContentResponse, None, None],
-    tool_types: list[type[GoogleTool]] | None = None,
-    partial_tools: bool = False,
-) -> Generator[tuple[GoogleCallResponseChunk, GoogleTool | None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed."""
-    for chunk in stream:
-        yield from _handle_chunk(chunk, tool_types)
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[GenerateContentResponse, None],
-    tool_types: list[type[GoogleTool]] | None = None,
-    partial_tools: bool = False,
-) -> AsyncGenerator[tuple[GoogleCallResponseChunk, GoogleTool | None], None]:
-    """
-    Async iterator over the stream and constructs tools as they are streamed.
-
-    Note: google does not currently support streaming tools.
-    """
-    async for chunk in stream:
-        for call_response_chunk, tool in _handle_chunk(chunk, tool_types):
-            yield call_response_chunk, tool

mirascope/core/google/_utils/_message_param_converter.py

@@ -1,200 +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, DocumentURLPart, 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_document_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 in [
-                        "application/pdf",
-                        "application/x-javascript",
-                        "text/javascript",
-                        "application/x-python",
-                        "text/x-python",
-                        "text/plain",
-                        "text/html",
-                        "text/css",
-                        "text/csv",
-                        "text/xml",
-                        "text/rtf",
-                        "text/md",
-                    ]:
-                        _check_document_media_type(mime_type)
-                        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),
-                            )
-                        )
-                    elif mime_type in [
-                        "application/pdf",
-                        "application/x-javascript",
-                        "text/javascript",
-                        "application/x-python",
-                        "text/x-python",
-                        "text/plain",
-                        "text/html",
-                        "text/css",
-                        "text/csv",
-                        "text/xml",
-                        "text/rtf",
-                        "text/md",
-                    ]:
-                        content_list.append(
-                            DocumentURLPart(
-                                type="document_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, audio, 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,58 +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."
-        )
-
-
-def _check_document_media_type(media_type: str) -> None:
-    """Raises a `ValueError` if the document media type is not supported."""
-
-    if media_type not in [
-        "application/pdf",
-        "application/x-javascript",
-        "text/javascript",
-        "application/x-python",
-        "text/x-python",
-        "text/plain",
-        "text/html",
-        "text/css",
-        "text/csv",
-        "text/xml",
-        "text/rtf",
-        "text/md",
-    ]:
-        raise ValueError(
-            f"Unsupported document media type: {media_type}. "
-            "Google currently only supports PDF, JavaScript, Python, TXT, HTML, CSS, "
-            "CSV, XML, RTF, and Markdown document 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]