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

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]
-        )

mirascope/core/vertex/dynamic_config.py

@@ -1,28 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from vertexai.generative_models import (
-    Content,
-    GenerativeModel,
-)
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import VertexCallParams
-
-VertexDynamicConfig = BaseDynamicConfig[
-    Content | BaseMessageParam, VertexCallParams, GenerativeModel
-]
-"""The function return type for functions wrapped with the `vertex_call` decorator.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.vertex import VertexDynamicConfig, vertex_call
-
-
-@vertex_call("gemini-1.5-flash")
-@prompt_template("Recommend a {capitalized_genre} book")
-def recommend_book(genre: str) -> VertexDynamicConfig:
-    return {"computed_fields": {"capitalized_genre": genre.capitalize()}}
-```
-"""

mirascope/core/vertex/stream.py

@@ -1,119 +0,0 @@
-"""The `VertexStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from typing import cast
-
-from google.cloud.aiplatform_v1beta1.types import FunctionCall
-from vertexai.generative_models import (
-    Candidate,
-    Content,
-    FinishReason,
-    GenerationResponse,
-    Part,
-    Tool,
-)
-
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from .call_params import VertexCallParams
-from .call_response import VertexCallResponse
-from .call_response_chunk import VertexCallResponseChunk
-from .dynamic_config import VertexDynamicConfig
-from .tool import VertexTool
-
-
-class VertexStream(
-    BaseStream[
-        VertexCallResponse,
-        VertexCallResponseChunk,
-        Content,
-        Content,
-        Content,
-        Content,
-        VertexTool,
-        Tool,
-        VertexDynamicConfig,
-        VertexCallParams,
-        FinishReason,
-    ]
-):
-    """A class for convenience around streaming Vertex LLM calls.
-
-    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")  # returns `VertexStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "vertex"
-
-    def _construct_message_param(
-        self,
-        tool_calls: list[FunctionCall] | None = None,
-        content: str | None = None,
-    ) -> Content:
-        """Constructs the message parameter for the assistant."""
-        return Content(
-            role="model",
-            parts=cast(list[Part], [Part.from_text(content)] + (tool_calls or [])),  # pyright: ignore [reportArgumentType]
-        )
-
-    def construct_call_response(self) -> VertexCallResponse:
-        """Constructs the call response from a consumed VertexStream.
-
-        Raises:
-            ValueError: if the stream has not yet been consumed.
-        """
-        if not hasattr(self, "message_param"):
-            raise ValueError(
-                "No stream response, check if the stream has been consumed."
-            )
-        response = GenerationResponse.from_dict(
-            {
-                "candidates": [
-                    Candidate.from_dict(
-                        {
-                            "finish_reason": self.finish_reasons[0]
-                            if self.finish_reasons
-                            else FinishReason.STOP,
-                            "content": Content(
-                                role=self.message_param.role,
-                                parts=self.message_param.parts,
-                            ).to_dict(),
-                        }
-                    ).to_dict()
-                ]
-            }
-        )
-        return VertexCallResponse(
-            metadata=self.metadata,
-            response=response,
-            tool_types=self.tool_types,
-            prompt_template=self.prompt_template,
-            fn_args=self.fn_args if self.fn_args else {},
-            dynamic_config=self.dynamic_config,
-            messages=self.messages,
-            call_params=self.call_params,
-            call_kwargs=self.call_kwargs,
-            user_message_param=self.user_message_param,
-            start_time=self.start_time,
-            end_time=self.end_time,
-        )
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        return super().cost_metadata