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

mirascope/core/google/call_response.py

@@ -1,255 +0,0 @@
-"""This module contains the `GoogleCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-
-from google.genai.types import (
-    ContentDict,
-    ContentListUnion,
-    ContentListUnionDict,
-    FunctionResponseDict,
-    GenerateContentResponse,
-    GenerateContentResponseUsageMetadata,
-    Part,
-    PartDict,
-    # Import manually SchemaDict to avoid Pydantic error
-    SchemaDict,  # noqa: F401
-    Tool,
-)
-from pydantic import computed_field
-
-from .. import BaseMessageParam
-from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import CostMetadata, FinishReason, GoogleMetadata
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-from ._utils._message_param_converter import GoogleMessageParamConverter
-from .call_params import GoogleCallParams
-from .dynamic_config import GoogleDynamicConfig
-from .tool import GoogleTool
-
-
-class GoogleCallResponse(
-    BaseCallResponse[
-        GenerateContentResponse,
-        GoogleTool,
-        Tool,
-        GoogleDynamicConfig,
-        ContentListUnion | ContentListUnionDict,
-        GoogleCallParams,
-        ContentDict,
-        GoogleMessageParamConverter,
-    ]
-):
-    """A convenience wrapper around the Google API response.
-
-    When calling the Google API using a function decorated with `google_call`, the
-    response will be a `GoogleCallResponse` instance with properties that allow for
-    more convenient access to commonly used attributes.
-
-
-    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")  # response is an `GoogleCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _message_converter: type[GoogleMessageParamConverter] = GoogleMessageParamConverter
-
-    _provider = "google"
-
-    def _parts(self) -> list[Part]:
-        """Returns the parts of the 0th candidate."""
-        if (
-            not (candidates := self.response.candidates)
-            or not (content := candidates[0].content)
-            or not (parts := content.parts)
-        ):
-            return []
-        return parts
-
-    @computed_field
-    @property
-    def content(self) -> str:
-        """Returns the contained string content for the 0th choice."""
-        for part in self._parts():
-            if not part.thought and part.text:
-                return part.text
-        return ""
-
-    @computed_field
-    @property
-    def thinking(self) -> str | None:
-        """Returns the thought content from the first thought part"""
-        for part in self._parts():
-            if part.thought and part.text:
-                return part.text
-        return None
-
-    @computed_field
-    @property
-    def finish_reasons(self) -> list[str]:
-        """Returns the finish reasons of the response."""
-
-        return [
-            candidate.finish_reason.value
-            for candidate in (self.response.candidates or [])
-            if candidate and candidate.finish_reason is not None
-        ]
-
-    @computed_field
-    @property
-    def model(self) -> str:
-        """Returns the model name.
-
-        google.generativeai does not return model, so we return the model provided by
-        the user.
-        """
-        return (
-            self.response.model_version if self.response.model_version else self._model
-        )
-
-    @computed_field
-    @property
-    def id(self) -> str | None:
-        """Returns the id of the response.
-
-        google.generativeai does not return an id
-        """
-        return None
-
-    @property
-    def usage(self) -> GenerateContentResponseUsageMetadata | None:
-        """Returns the usage of the chat completion.
-
-        google.generativeai does not have Usage, so we return None
-        """
-        return self.response.usage_metadata
-
-    @computed_field
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        return (
-            self.response.usage_metadata.prompt_token_count
-            if self.response.usage_metadata
-            else None
-        )
-
-    @computed_field
-    @property
-    def cached_tokens(self) -> int | None:
-        """Returns the number of cached tokens."""
-        return (
-            self.response.usage_metadata.cached_content_token_count
-            if self.response.usage_metadata
-            else None
-        )
-
-    @computed_field
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        return (
-            self.response.usage_metadata.candidates_token_count
-            if self.response.usage_metadata
-            else None
-        )
-
-    @computed_field
-    @cached_property
-    def message_param(self) -> ContentDict:
-        """Returns the models's response as a message parameter."""
-        return {"role": "model", "parts": self.response.candidates[0].content.parts}  # pyright: ignore [reportReturnType, reportOptionalSubscript, reportOptionalMemberAccess]
-
-    @cached_property
-    def tools(self) -> list[GoogleTool] | None:
-        """Returns the list of tools for the response."""
-        if self.tool_types is None:
-            return None
-
-        extracted_tools = []
-        for tool_call in self.response.function_calls or []:
-            for tool_type in self.tool_types:
-                if tool_call.name == tool_type._name():  # pyright: ignore [reportOptionalMemberAccess]
-                    extracted_tools.append(tool_type.from_tool_call(tool_call))  # pyright: ignore [reportArgumentType]
-                    break
-
-        return extracted_tools
-
-    @cached_property
-    def tool(self) -> GoogleTool | 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[GoogleTool, str]]
-    ) -> list[ContentDict]:
-        """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 `FunctionResponse` parameters.
-        """
-        return [
-            {
-                "role": "user",
-                "parts": [
-                    PartDict(
-                        function_response=FunctionResponseDict(
-                            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 GoogleMessageParamConverter.from_provider([self.message_param])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return GoogleMessageParamConverter.from_provider([self.user_message_param])[0]
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        cost_metadata = super().cost_metadata
-        cost_metadata.google = GoogleMetadata(
-            use_vertex_ai="use_vertex_ai" in self.metadata.get("tags", [])
-        )
-        return cost_metadata

mirascope/core/google/call_response_chunk.py

@@ -1,135 +0,0 @@
-"""This module contains the `GoogleCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from typing import cast
-
-from google.genai.types import FinishReason as GoogleFinishReason
-from google.genai.types import (
-    GenerateContentResponse,
-    GenerateContentResponseUsageMetadata,
-)
-
-from mirascope.core.base.types import CostMetadata, FinishReason
-
-from ..base import BaseCallResponseChunk
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-
-
-class GoogleCallResponseChunk(
-    BaseCallResponseChunk[GenerateContentResponse, GoogleFinishReason]
-):
-    """A convenience wrapper around the Google API streamed response chunks.
-
-    When calling the Google API using a function decorated with `google_call` and
-    `stream` set to `True`, the stream will contain `GoogleCallResponseChunk` instances
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.google import google_call
-
-
-    @google_call("google-1.5-flash", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    stream = recommend_book("fantasy")  # response is an `GoogleStream`
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    @property
-    def content(self) -> str:
-        """Returns the chunk content for the 0th choice."""
-        if (
-            not (candidates := self.chunk.candidates)
-            or not (content := candidates[0].content)
-            or not (parts := content.parts)
-        ):
-            return ""
-
-        for part in parts:
-            if not part.thought and part.text:
-                return part.text
-        return ""
-
-    @property
-    def thinking(self) -> str:
-        """Returns the thinking content from thinking parts."""
-        if (
-            not (candidates := self.chunk.candidates)
-            or not (content := candidates[0].content)
-            or not (parts := content.parts)
-        ):
-            return ""
-
-        for part in parts:
-            if part.thought and part.text:
-                return part.text
-        return ""
-
-    @property
-    def finish_reasons(self) -> list[GoogleFinishReason]:
-        """Returns the finish reasons of the response."""
-        return [
-            candidate.finish_reason
-            for candidate in (self.chunk.candidates or [])
-            if candidate.finish_reason is not None
-        ]
-
-    @property
-    def model(self) -> str | None:
-        """Returns the model name.
-
-        google.generativeai does not return model, so we return None
-        """
-        return self.chunk.model_version
-
-    @property
-    def id(self) -> str | None:
-        """Returns the id of the response.
-
-        google.generativeai does not return an id
-        """
-        return None
-
-    @property
-    def usage(self) -> GenerateContentResponseUsageMetadata | None:
-        """Returns the usage of the chat completion.
-
-        google.generativeai does not have Usage, so we return None
-        """
-        return self.chunk.usage_metadata
-
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        return self.usage.prompt_token_count if self.usage else None
-
-    @property
-    def cached_tokens(self) -> int | None:
-        """Returns the number of cached tokens."""
-        return self.usage.cached_content_token_count if self.usage else None
-
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        return self.usage.candidates_token_count if self.usage else None
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Returns the cost metadata."""
-        return super().cost_metadata
-
-    @property
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(
-            cast(list[str], self.finish_reasons)
-        )

mirascope/core/google/dynamic_config.py

@@ -1,26 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from google.genai import Client
-from google.genai.types import ContentListUnion, ContentListUnionDict
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import GoogleCallParams
-
-GoogleDynamicConfig = BaseDynamicConfig[
-    ContentListUnion | ContentListUnionDict | BaseMessageParam, GoogleCallParams, Client
-]
-"""The function return type for functions wrapped with the `google_call` decorator.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.google import GoogleDynamicConfig, google_call
-
-
-@google_call("google-1.5-flash")
-@prompt_template("Recommend a {capitalized_genre} book")
-def recommend_book(genre: str) -> GoogleDynamicConfig:
-    return {"computed_fields": {"capitalized_genre": genre.capitalize()}}
-```
-"""

mirascope/core/google/stream.py

@@ -1,199 +0,0 @@
-"""The `GoogleStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from collections.abc import AsyncGenerator, Generator
-from typing import Any, cast
-
-from google.genai.types import (
-    Candidate,
-    Content,
-    ContentDict,
-    ContentListUnion,
-    ContentListUnionDict,
-    FinishReason,
-    FunctionCall,
-    GenerateContentResponse,
-    GenerateContentResponseUsageMetadata,
-    PartDict,
-    Tool,
-)
-
-from ..base.call_kwargs import BaseCallKwargs
-from ..base.metadata import Metadata
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from .call_params import GoogleCallParams
-from .call_response import GoogleCallResponse
-from .call_response_chunk import GoogleCallResponseChunk
-from .dynamic_config import GoogleDynamicConfig
-from .tool import GoogleTool
-
-
-class GoogleStream(
-    BaseStream[
-        GoogleCallResponse,
-        GoogleCallResponseChunk,
-        ContentDict,
-        ContentDict,
-        ContentDict,
-        ContentListUnion | ContentListUnionDict,
-        GoogleTool,
-        Tool,
-        GoogleDynamicConfig,
-        GoogleCallParams,
-        FinishReason,
-    ]
-):
-    """A class for convenience around streaming Google LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.google import google_call
-
-
-    @google_call("google-1.5-flash", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-    stream = recommend_book("fantasy")  # returns `GoogleStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "google"
-
-    def __init__(
-        self,
-        *,
-        stream: Generator[tuple[GoogleCallResponseChunk, GoogleTool | None], None, None]
-        | AsyncGenerator[tuple[GoogleCallResponseChunk, GoogleTool | None], None],
-        metadata: Metadata,
-        tool_types: list[type[GoogleTool]] | None,
-        call_response_type: type[GoogleCallResponse],
-        model: str,
-        prompt_template: str | None,
-        fn_args: dict[str, Any],
-        dynamic_config: GoogleDynamicConfig,
-        messages: list[ContentListUnion | ContentListUnionDict],
-        call_params: GoogleCallParams,
-        call_kwargs: BaseCallKwargs[Tool],
-    ) -> None:
-        """Initialize GoogleStream with thinking content tracking."""
-        super().__init__(
-            stream=stream,
-            metadata=metadata,
-            tool_types=tool_types,
-            call_response_type=call_response_type,
-            model=model,
-            prompt_template=prompt_template,
-            fn_args=fn_args,
-            dynamic_config=dynamic_config,
-            messages=messages,
-            call_params=call_params,
-            call_kwargs=call_kwargs,
-        )
-        self.thinking = ""
-
-    def _update_properties(self, chunk: GoogleCallResponseChunk) -> None:
-        """Updates the properties of the stream, including thinking content."""
-        super()._update_properties(chunk)
-        self.thinking += chunk.thinking
-
-    def _construct_message_param(
-        self, tool_calls: list[FunctionCall] | None = None, content: str | None = None
-    ) -> ContentDict:
-        """Constructs the message parameter for the assistant."""
-        return {
-            "role": "model",
-            "parts": cast(
-                list[PartDict],
-                [{"text": content}]
-                + (
-                    [
-                        {"function_call": tool_call}
-                        for tool_call in (tool_calls or [])
-                        if tool_calls
-                    ]
-                    or []
-                ),
-            ),
-        }
-
-    def construct_call_response(self) -> GoogleCallResponse:
-        """Constructs the call response from a consumed GoogleStream.
-
-        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."
-            )
-        candidates_token_count = (
-            int(self.output_tokens) if self.output_tokens is not None else None
-        )
-        prompt_token_count = (
-            int(self.input_tokens) if self.input_tokens is not None else None
-        )
-        total_token_count = int(candidates_token_count or 0) + int(
-            prompt_token_count or 0
-        )
-
-        parts: list[PartDict] = []
-
-        # Add thinking part first if we have thinking content
-        if self.thinking:
-            parts.append({"text": self.thinking, "thought": True})
-
-        for pd in self.message_param.get("parts") or []:
-            if pd.get("text") == "":
-                # These parts are generated based only on chunk content;
-                # thinking parts have empty content and are reconstructed separately.
-                # Skip this so the thinking parts aren't duplicated.
-                continue
-            else:
-                parts.append(pd)
-
-        response = GenerateContentResponse(
-            candidates=[
-                Candidate(
-                    finish_reason=self.finish_reasons[0]
-                    if self.finish_reasons
-                    else FinishReason.STOP,
-                    content=Content(
-                        role=self.message_param["role"],  # pyright: ignore [reportTypedDictNotRequiredAccess]
-                        parts=parts,  # pyright: ignore [reportArgumentType]
-                    ),
-                )
-            ],
-            model_version=self.model,
-            usage_metadata=GenerateContentResponseUsageMetadata(
-                candidates_token_count=candidates_token_count,
-                prompt_token_count=prompt_token_count,
-                total_token_count=total_token_count,
-            ),
-        )
-
-        return GoogleCallResponse(
-            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