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

mirascope/core/gemini/_utils/_setup_call.py

@@ -1,149 +0,0 @@
-"""This module contains the setup_call function, which is used to set up the"""
-
-from collections.abc import Awaitable, Callable
-from dataclasses import asdict, is_dataclass
-from typing import Any, cast, overload
-
-from google.generativeai import GenerativeModel
-from google.generativeai.types import (
-    AsyncGenerateContentResponse,
-    ContentDict,
-    GenerateContentResponse,
-    GenerationConfigDict,
-)
-from google.generativeai.types.content_types import ToolConfigDict, to_content
-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 GeminiCallKwargs
-from ..call_params import GeminiCallParams
-from ..dynamic_config import GeminiDynamicConfig
-from ..tool import GeminiTool
-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[GeminiDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: GeminiDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GeminiCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[AsyncGenerateContentResponse, AsyncGenerateContentResponse],
-    str | None,
-    list[ContentDict],
-    list[type[GeminiTool]] | None,
-    GeminiCallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: GenerativeModel | None,
-    fn: Callable[..., GeminiDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: GeminiDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GeminiCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[GenerateContentResponse, GenerateContentResponse],
-    str | None,
-    list[ContentDict],
-    list[type[GeminiTool]] | None,
-    GeminiCallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: GenerativeModel | None,
-    fn: Callable[..., GeminiDynamicConfig | Awaitable[GeminiDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: GeminiDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GeminiCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[GenerateContentResponse, GenerateContentResponse]
-    | AsyncCreateFn[AsyncGenerateContentResponse, AsyncGenerateContentResponse],
-    str | None,
-    list[ContentDict],
-    list[type[GeminiTool]] | None,
-    GeminiCallKwargs,
-]:
-    prompt_template, messages, tool_types, base_call_kwargs = _utils.setup_call(
-        fn,
-        fn_args,
-        dynamic_config,
-        tools,
-        GeminiTool,
-        call_params,
-        convert_common_call_params,
-    )
-    call_kwargs = cast(GeminiCallKwargs, base_call_kwargs)
-    messages = cast(list[BaseMessageParam | ContentDict], messages)
-    messages = convert_message_params(messages)
-
-    if json_mode:
-        generation_config = call_kwargs.get("generation_config", {})
-        if is_dataclass(generation_config):
-            generation_config = asdict(generation_config)
-        if not tools:
-            generation_config["response_mime_type"] = "application/json"
-        call_kwargs["generation_config"] = cast(GenerationConfigDict, generation_config)
-        messages[-1]["parts"].append(_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 = ToolConfigDict()
-        tool_config.function_calling_config = {
-            "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
-        system_instruction = (
-            list(system_instruction.parts) if system_instruction else []
-        )
-        system_instruction.extend(messages.pop(0)["parts"])  # pyright: ignore [reportArgumentType]
-        client._system_instruction = to_content(system_instruction)  # pyright: ignore [reportArgumentType]
-
-    call_kwargs |= {"contents": messages}
-
-    create = (
-        get_async_create_fn(client.generate_content_async)
-        if fn_is_async(fn)
-        else get_create_fn(client.generate_content)
-    )
-
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/gemini/call_params.py

@@ -1,52 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from google.generativeai.types.content_types import ToolConfigType
-from google.generativeai.types.safety_types import SafetySettingOptions
-from pydantic import ConfigDict, with_config
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-if TYPE_CHECKING:
-    from google.generativeai.types import (
-        GenerationConfig,
-        GenerationConfigDict,
-        RequestOptions,
-    )
-else:
-    from google.generativeai.types import (
-        GenerationConfig as _GenerationConfig,
-    )
-    from google.generativeai.types import GenerationConfigDict as _GenerationConfigDict
-    from google.generativeai.types import RequestOptions as _RequestOptions
-
-    @with_config(ConfigDict(arbitrary_types_allowed=True))
-    class GenerationConfigDict(_GenerationConfigDict): ...
-
-    class GenerationConfig(_GenerationConfig):
-        __pydantic_config__ = ConfigDict(arbitrary_types_allowed=True)
-
-    class RequestOptions(_RequestOptions):
-        __pydantic_config__ = ConfigDict(arbitrary_types_allowed=True)
-
-
-class GeminiCallParams(BaseCallParams):
-    """The parameters to use when calling the Gemini API.
-
-    [Gemini API Reference](https://ai.google.dev/gemini-api/docs/text-generation?lang=python)
-
-    Attributes:
-        generation_config: ...
-        safety_settings: ...
-        request_options: ...
-        tool_config: ...
-    """
-
-    generation_config: NotRequired[GenerationConfigDict | GenerationConfig]
-    safety_settings: NotRequired[SafetySettingOptions]
-    request_options: NotRequired[RequestOptions]
-    tool_config: NotRequired[ToolConfigType]

mirascope/core/gemini/call_response.py

@@ -1,216 +0,0 @@
-"""This module contains the `GeminiCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-
-from google.generativeai.protos import FunctionResponse
-from google.generativeai.types import (
-    AsyncGenerateContentResponse,
-    ContentDict,
-    ContentsType,  # type: ignore
-    GenerateContentResponse,
-    Tool,
-)
-from pydantic import computed_field
-
-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 GeminiMessageParamConverter
-from .call_params import GeminiCallParams
-from .dynamic_config import GeminiDynamicConfig
-from .tool import GeminiTool
-
-
-class GeminiCallResponse(
-    BaseCallResponse[
-        GenerateContentResponse | AsyncGenerateContentResponse,
-        GeminiTool,
-        Tool,
-        GeminiDynamicConfig,
-        ContentsType,
-        GeminiCallParams,
-        ContentDict,
-        GeminiMessageParamConverter,
-    ]
-):
-    """A convenience wrapper around the Gemini API response.
-
-    When calling the Gemini API using a function decorated with `gemini_call`, the
-    response will be a `GeminiCallResponse` instance with properties that allow for
-    more convenient access to commonly used attributes.
-
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.gemini import gemini_call
-
-
-    @gemini_call("gemini-1.5-flash")
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")  # response is an `GeminiCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _message_converter: type[GeminiMessageParamConverter] = GeminiMessageParamConverter
-
-    _provider = "gemini"
-
-    @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.
-
-        google.generativeai 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.
-
-        google.generativeai does not return an id
-        """
-        return None
-
-    @property
-    def usage(self) -> None:
-        """Returns the usage of the chat completion.
-
-        google.generativeai does not have Usage, so we return None
-        """
-        return None
-
-    @computed_field
-    @property
-    def input_tokens(self) -> None:
-        """Returns the number of input tokens."""
-        return None
-
-    @computed_field
-    @property
-    def cached_tokens(self) -> None:
-        """Returns the number of cached tokens."""
-        return None
-
-    @computed_field
-    @property
-    def output_tokens(self) -> None:
-        """Returns the number of output tokens."""
-        return 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.parts}  # pyright: ignore [reportReturnType]
-
-    @cached_property
-    def tools(self) -> list[GeminiTool] | 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) -> GeminiTool | 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[GeminiTool, 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": [
-                    FunctionResponse(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 GeminiMessageParamConverter.from_provider([self.message_param])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return GeminiMessageParamConverter.from_provider([self.user_message_param])[0]
-
-    @computed_field
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Get metadata required for cost calculation."""
-        return super().cost_metadata

mirascope/core/gemini/call_response_chunk.py

@@ -1,100 +0,0 @@
-"""This module contains the `GeminiCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from google.ai.generativelanguage import Candidate
-from google.generativeai.types import GenerateContentResponse
-
-from ..base import BaseCallResponseChunk
-from ..base.types import CostMetadata, FinishReason
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-
-
-class GeminiCallResponseChunk(
-    BaseCallResponseChunk[GenerateContentResponse, Candidate.FinishReason]
-):
-    """A convenience wrapper around the Gemini API streamed response chunks.
-
-    When calling the Gemini API using a function decorated with `gemini_call` and
-    `stream` set to `True`, the stream will contain `GeminiCallResponseChunk` instances
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.gemini import gemini_call
-
-
-    @gemini_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 `GeminiStream`
-    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[Candidate.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.
-
-        google.generativeai does not return model, so we return None
-        """
-        return None
-
-    @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) -> None:
-        """Returns the usage of the chat completion.
-
-        google.generativeai 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[FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(
-            [finish_reason.name for finish_reason in self.finish_reasons]
-        )

mirascope/core/gemini/dynamic_config.py

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

mirascope/core/gemini/stream.py

@@ -1,120 +0,0 @@
-"""The `GeminiStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from typing import cast
-
-from google.ai.generativelanguage import (
-    Candidate,
-    Content,
-    FunctionCall,
-    GenerateContentResponse,
-)
-from google.generativeai.types import (
-    ContentDict,
-    ContentsType,
-    Tool,
-)
-from google.generativeai.types import (
-    GenerateContentResponse as GenerateContentResponseType,
-)
-from google.generativeai.types.content_types import PartType
-
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from .call_params import GeminiCallParams
-from .call_response import GeminiCallResponse
-from .call_response_chunk import GeminiCallResponseChunk
-from .dynamic_config import GeminiDynamicConfig
-from .tool import GeminiTool
-
-
-class GeminiStream(
-    BaseStream[
-        GeminiCallResponse,
-        GeminiCallResponseChunk,
-        ContentDict,
-        ContentDict,
-        ContentDict,
-        ContentsType,
-        GeminiTool,
-        Tool,
-        GeminiDynamicConfig,
-        GeminiCallParams,
-        Candidate.FinishReason,
-    ]
-):
-    """A class for convenience around streaming Gemini LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.gemini import gemini_call
-
-
-    @gemini_call("gemini-1.5-flash", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-    stream = recommend_book("fantasy")  # returns `GeminiStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "gemini"
-
-    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[PartType], [{"text": content}] + (tool_calls or [])),
-        }
-
-    def construct_call_response(self) -> GeminiCallResponse:
-        """Constructs the call response from a consumed GeminiStream.
-
-        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 = GenerateContentResponseType.from_response(
-            GenerateContentResponse(
-                candidates=[
-                    Candidate(
-                        finish_reason=self.finish_reasons[0]
-                        if self.finish_reasons
-                        else Candidate.FinishReason.STOP,
-                        content=Content(
-                            role=self.message_param["role"],
-                            parts=self.message_param["parts"],
-                        ),
-                    )
-                ]
-            )
-        )
-        return GeminiCallResponse(
-            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