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

mirascope/core/vertex/_utils/_get_json_output.py

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

mirascope/core/vertex/_utils/_handle_stream.py

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

mirascope/core/vertex/_utils/_message_param_converter.py

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

mirascope/core/vertex/_utils/_setup_call.py

@@ -1,160 +0,0 @@
-"""This module contains the setup_call function, which is used to set up the"""
-
-from collections.abc import AsyncIterable, Awaitable, Callable, Iterable
-from typing import Any, cast, overload
-
-from google.cloud.aiplatform_v1beta1.types import FunctionCallingConfig
-from pydantic import BaseModel
-from vertexai.generative_models import (
-    Content,
-    GenerationConfig,
-    GenerationResponse,
-    GenerativeModel,
-    Part,
-    ToolConfig,
-)
-
-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 VertexCallKwargs
-from ..call_params import VertexCallParams
-from ..dynamic_config import VertexDynamicConfig
-from ..tool import VertexTool
-from ._convert_common_call_params import convert_common_call_params
-from ._convert_message_params import convert_message_params
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: GenerativeModel | None,
-    fn: Callable[..., Awaitable[VertexDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: VertexDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: VertexCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[GenerationResponse, AsyncIterable[GenerationResponse]],
-    str | None,
-    list[Content],
-    list[type[VertexTool]] | None,
-    VertexCallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: GenerativeModel | None,
-    fn: Callable[..., VertexDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: VertexDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: VertexCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[GenerationResponse, Iterable[GenerationResponse]],
-    str | None,
-    list[Content],
-    list[type[VertexTool]] | None,
-    VertexCallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: GenerativeModel | None,
-    fn: Callable[..., VertexDynamicConfig | Awaitable[VertexDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: VertexDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: VertexCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[GenerationResponse, Iterable[GenerationResponse]]
-    | AsyncCreateFn[GenerationResponse, AsyncIterable[GenerationResponse]],
-    str | None,
-    list[Content],
-    list[type[VertexTool]] | None,
-    VertexCallKwargs,
-]:
-    prompt_template, messages, tool_types, base_call_kwargs = _utils.setup_call(
-        fn,
-        fn_args,
-        dynamic_config,
-        tools,
-        VertexTool,
-        call_params,
-        convert_common_call_params,
-    )
-    call_kwargs = cast(VertexCallKwargs, base_call_kwargs)
-    messages = cast(list[BaseMessageParam | Content], messages)
-    messages = convert_message_params(messages)
-
-    if json_mode:
-        generation_config = call_kwargs.get(
-            "generation_config",
-            GenerationConfig(response_mime_type="application/json")
-            if not tools
-            else GenerationConfig(),
-        )
-        call_kwargs["generation_config"] = generation_config
-        messages[-1] = Content(
-            role="user",
-            parts=messages[-1].parts
-            + [Part.from_text(_utils.json_mode_content(response_model))],
-        )
-    elif response_model:
-        assert tool_types, "At least one tool must be provided for extraction."
-        call_kwargs.pop("tool_config", None)
-        tool_config = ToolConfig(
-            function_calling_config=ToolConfig.FunctionCallingConfig(
-                mode=FunctionCallingConfig.Mode.ANY,
-                allowed_function_names=[tool_types[0]._name()],
-            )
-        )
-        call_kwargs["tool_config"] = tool_config
-
-    if client is None:
-        client = GenerativeModel(model_name=model)
-
-    if messages and messages[0].role == "system":
-        system_instruction = client._system_instruction
-        if not isinstance(system_instruction, list):
-            system_instruction = [system_instruction] if system_instruction else []
-        system_instruction.extend(messages.pop(0).parts)
-        client._system_instruction = system_instruction
-
-    call_kwargs |= {"contents": messages}
-
-    create = (
-        cast(
-            AsyncCreateFn[GenerationResponse, AsyncIterable[GenerationResponse]],
-            get_async_create_fn(client.generate_content_async),
-        )
-        if fn_is_async(fn)
-        else cast(
-            CreateFn[GenerationResponse, Iterable[GenerationResponse]],
-            get_create_fn(client.generate_content),
-        )
-    )
-
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/vertex/call_params.py

@@ -1,24 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from typing_extensions import NotRequired
-from vertexai.generative_models import GenerationConfig, SafetySetting, ToolConfig
-
-from ..base import BaseCallParams
-
-
-class VertexCallParams(BaseCallParams):
-    """The parameters to use when calling the Vertex API.
-
-    [Vertex API Reference](https://cloud.google.com/python/docs/reference/aiplatform/latest)
-
-    Attributes:
-        generation_config: ...
-        safety_settings: ...
-        tool_config: ...
-    """
-
-    generation_config: NotRequired[GenerationConfig]
-    safety_settings: NotRequired[SafetySetting]
-    tool_config: NotRequired[ToolConfig]

mirascope/core/vertex/call_response.py

@@ -1,206 +0,0 @@
-"""This module contains the `VertexCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-
-from google.cloud.aiplatform_v1beta1.types import GenerateContentResponse
-from pydantic import computed_field
-from vertexai.generative_models import Content, GenerationResponse, Part, Tool
-
-from .. import BaseMessageParam
-from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import CostMetadata, FinishReason
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-from ._utils._message_param_converter import VertexMessageParamConverter
-from .call_params import VertexCallParams
-from .dynamic_config import VertexDynamicConfig
-from .tool import VertexTool
-
-
-class VertexCallResponse(
-    BaseCallResponse[
-        GenerationResponse,
-        VertexTool,
-        Tool,
-        VertexDynamicConfig,
-        Content,
-        VertexCallParams,
-        Content,
-        VertexMessageParamConverter,
-    ]
-):
-    """A convenience wrapper around the Vertex AI `GenerateContentResponse`.
-
-    When calling the Vertex AI API using a function decorated with `vertex_call`, the
-    response will be a `VertexCallResponse` instance with properties that allow for
-    more convenient access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.vertex import vertex_call
-
-
-    @vertex_call("gemini-1.5-flash")
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")  # response is an `VertexCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _message_converter: type[VertexMessageParamConverter] = VertexMessageParamConverter
-
-    _provider = "vertex"
-
-    @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
-
-    @computed_field
-    @property
-    def finish_reasons(self) -> list[str]:
-        """Returns the finish reasons of the response."""
-        finish_reasons = [
-            "FINISH_REASON_UNSPECIFIED",
-            "STOP",
-            "MAX_TOKENS",
-            "SAFETY",
-            "RECITATION",
-            "OTHER",
-        ]
-
-        return [
-            finish_reasons[candidate.finish_reason]
-            for candidate in self.response.candidates
-        ]
-
-    @computed_field
-    @property
-    def model(self) -> str:
-        """Returns the model name.
-
-        vertex does not return model, so we return the model provided by
-        the user.
-        """
-        return self._model
-
-    @computed_field
-    @property
-    def id(self) -> str | None:
-        """Returns the id of the response.
-
-        vertex does not return an id
-        """
-        return None
-
-    @property
-    def usage(self) -> GenerateContentResponse.UsageMetadata:
-        """Returns the usage of the chat completion."""
-        return self.response.usage_metadata
-
-    @computed_field
-    @property
-    def input_tokens(self) -> int:
-        """Returns the number of input tokens."""
-        return self.usage.prompt_token_count
-
-    @computed_field
-    @property
-    def cached_tokens(self) -> int:
-        """Returns the number of cached tokens."""
-        return 0
-
-    @computed_field
-    @property
-    def output_tokens(self) -> int:
-        """Returns the number of output tokens."""
-        return self.usage.candidates_token_count
-
-    @computed_field
-    @cached_property
-    def message_param(self) -> Content:
-        """Returns the models's response as a message parameter."""
-        return Content(role="model", parts=self.response.candidates[0].content.parts)
-
-    @cached_property
-    def tools(self) -> list[VertexTool] | None:
-        """Returns the list of tools for the 0th candidate's 0th content part."""
-        if self.tool_types is None:
-            return None
-
-        extracted_tools = []
-        for part in self.response.candidates[0].content.parts:
-            tool_call = part.function_call
-            for tool_type in self.tool_types:
-                if tool_call.name == tool_type._name():
-                    extracted_tools.append(tool_type.from_tool_call(tool_call))
-                    break
-
-        return extracted_tools
-
-    @cached_property
-    def tool(self) -> VertexTool | 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[VertexTool, str]]
-    ) -> list[Content]:
-        """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 `Content` from the tool responses.
-        """
-        return [
-            Content(
-                role="user",
-                parts=[
-                    Part.from_function_response(
-                        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 VertexMessageParamConverter.from_provider([self.message_param])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return VertexMessageParamConverter.from_provider([self.user_message_param])[0]
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        return super().cost_metadata

mirascope/core/vertex/call_response_chunk.py

@@ -1,99 +0,0 @@
-"""This module contains the `VertexCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from vertexai.generative_models import FinishReason, GenerationResponse
-
-from ..base import BaseCallResponseChunk, types
-from ..base.types import CostMetadata
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-
-
-class VertexCallResponseChunk(
-    BaseCallResponseChunk[GenerationResponse, FinishReason]  # , Candidate.FinishReason]
-):
-    """A convenience wrapper around the Vertex AI streamed response chunks.
-
-    When calling the Vertex AI API using a function decorated with `vertex_call` and
-    `stream` set to `True`, the stream will contain `VertexCallResponseChunk` instances
-    with properties that allow for more convenient access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.vertex import vertex_call
-
-
-    @vertex_call("gemini-1.5-flash", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-    stream = recommend_book("fantasy")  # response is an `VertexStream`
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    @property
-    def content(self) -> str:
-        """Returns the chunk content for the 0th choice."""
-        return self.chunk.candidates[0].content.parts[0].text
-
-    @property
-    def finish_reasons(self) -> list[FinishReason]:
-        """Returns the finish reasons of the response."""
-        return [candidate.finish_reason for candidate in self.chunk.candidates]
-
-    @property
-    def model(self) -> None:
-        """Returns the model name.
-
-        vertex does not return model, so we return None
-        """
-        return None
-
-    @property
-    def id(self) -> str | None:
-        """Returns the id of the response.
-
-        vertex does not return an id
-        """
-        return None
-
-    @property
-    def usage(self) -> None:
-        """Returns the usage of the chat completion.
-
-        vertex does not have Usage, so we return None
-        """
-        return None
-
-    @property
-    def input_tokens(self) -> None:
-        """Returns the number of input tokens."""
-        return None
-
-    @property
-    def cached_tokens(self) -> None:
-        """Returns the number of cached tokens."""
-        return None
-
-    @property
-    def output_tokens(self) -> None:
-        """Returns the number of output tokens."""
-        return None
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Returns the cost metadata."""
-        return super().cost_metadata
-
-    @property
-    def common_finish_reasons(self) -> list[types.FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(
-            [finish_reason.name for finish_reason in self.finish_reasons]
-        )