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

mirascope/core/gemini/_utils/_get_json_output.py

@@ -1,33 +0,0 @@
-"""Get JSON output from a Gemini response."""
-
-import json
-
-from proto.marshal.collections import RepeatedComposite
-
-from ..call_response import GeminiCallResponse
-from ..call_response_chunk import GeminiCallResponseChunk
-
-
-def get_json_output(
-    response: GeminiCallResponse | GeminiCallResponseChunk, json_mode: bool
-) -> str:
-    """Extracts the JSON output from a Gemini response."""
-    if isinstance(response, GeminiCallResponse):
-        if json_mode and response.content:
-            return response.content
-        elif tool_calls := [
-            part.function_call
-            for part in response.response.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("Gemini only supports structured streaming in json mode.")
-    return response.content

mirascope/core/gemini/_utils/_handle_stream.py

@@ -1,33 +0,0 @@
-"""Handles streaming content and tools from the Gemini API."""
-
-from collections.abc import AsyncGenerator, Generator
-
-from google.generativeai.types import GenerateContentResponse  # type: ignore
-
-from ..call_response_chunk import GeminiCallResponseChunk
-from ..tool import GeminiTool
-
-
-def handle_stream(
-    stream: Generator[GenerateContentResponse, None, None],
-    tool_types: list[type[GeminiTool]] | None = None,
-) -> Generator[tuple[GeminiCallResponseChunk, None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed.
-
-    Note: gemini does not currently support streaming tools.
-    """
-    for chunk in stream:
-        yield GeminiCallResponseChunk(chunk=chunk), None
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[GenerateContentResponse, None],
-    tool_types: list[type[GeminiTool]] | None = None,
-) -> AsyncGenerator[tuple[GeminiCallResponseChunk, None], None]:
-    """
-    Async iterator over the stream and constructs tools as they are streamed.
-
-    Note: gemini does not currently support streaming tools.
-    """
-    async for chunk in stream:
-        yield GeminiCallResponseChunk(chunk=chunk), None

mirascope/core/gemini/_utils/_setup_call.py

@@ -1,68 +0,0 @@
-"""This module contains the setup_call function, which is used to set up the"""
-
-import inspect
-from collections.abc import Awaitable, Callable
-from typing import Any, cast
-
-from google.generativeai import GenerativeModel  # type: ignore
-from google.generativeai.types import (  # type: ignore
-    AsyncGenerateContentResponse,
-    ContentDict,
-    GenerateContentResponse,
-)
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ..call_params import GeminiCallParams
-from ..dynamic_config import GeminiDynamicConfig
-from ..tool import GeminiTool
-from ._convert_message_params import convert_message_params
-
-
-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,
-    extract: bool = False,
-) -> tuple[
-    Callable[..., GenerateContentResponse]
-    | Callable[..., Awaitable[AsyncGenerateContentResponse]],
-    str,
-    list[ContentDict],
-    list[type[GeminiTool]] | None,
-    dict[str, Any],
-]:
-    prompt_template, messages, tool_types, call_kwargs = _utils.setup_call(
-        fn, fn_args, dynamic_config, tools, GeminiTool, call_params
-    )
-    messages = cast(list[BaseMessageParam | ContentDict], messages)
-    messages = convert_message_params(messages)
-    if json_mode:
-        generation_config = call_kwargs.get("generation_config", {})
-        generation_config["response_mime_type"] = "application/json"
-        call_kwargs["generation_config"] = generation_config
-        messages[-1]["parts"].append(
-            _utils.json_mode_content(tool_types[0] if tool_types else None)
-        )
-        call_kwargs.pop("tools", None)
-    elif extract:
-        assert tool_types, "At least one tool must be provided for extraction."
-        tool_config = call_kwargs.get("tool_config", {})
-        tool_config["function_calling_config"] = {"mode": "auto"}
-        call_kwargs["tool_config"] = tool_config
-    call_kwargs |= {"contents": messages}
-
-    if client is None:
-        client = GenerativeModel(model_name=model)
-    create = (
-        client.generate_content_async
-        if inspect.iscoroutinefunction(fn)
-        else client.generate_content
-    )
-
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/gemini/call_params.py

@@ -1,28 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from google.generativeai.types import GenerationConfig, RequestOptions
-from google.generativeai.types.content_types import ToolConfigType
-from google.generativeai.types.safety_types import SafetySettingOptions
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-
-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[GenerationConfig]
-    safety_settings: NotRequired[SafetySettingOptions]
-    request_options: NotRequired[RequestOptions]
-    tool_config: NotRequired[ToolConfigType]

mirascope/core/gemini/call_response.py

@@ -1,173 +0,0 @@
-"""This module contains the `GeminiCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from google.generativeai.protos import FunctionResponse  # type: ignore
-from google.generativeai.types import (  # type: ignore
-    AsyncGenerateContentResponse,
-    ContentDict,
-    ContentsType,  # type: ignore
-    GenerateContentResponse,
-)
-from pydantic import computed_field
-
-from ..base import BaseCallResponse
-from ._utils import calculate_cost
-from .call_params import GeminiCallParams
-from .dynamic_config import GeminiDynamicConfig
-from .tool import GeminiTool
-
-
-class GeminiCallResponse(
-    BaseCallResponse[
-        GenerateContentResponse | AsyncGenerateContentResponse,
-        GeminiTool,
-        GeminiDynamicConfig,
-        ContentsType,
-        GeminiCallParams,
-        ContentDict,
-    ]
-):
-    """Convenience wrapper around Gemini's `GenerateContentResponse`.
-
-    When using Mirascope's convenience wrappers to interact with Gemini models via
-    `GeminiCall`, responses using `GeminiCall.call()` will return a
-    `GeminiCallResponse`, whereby the implemented properties allow for simpler syntax
-    and a convenient developer experience.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.gemini import gemini_call
-
-
-    @gemini_call("gemini-1.5-flash")
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")  # response is an `GeminiCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _provider = "gemini"
-
-    @property
-    def content(self) -> str:
-        """Returns the contained string content for the 0th choice."""
-        return self.response.candidates[0].content.parts[0].text
-
-    @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
-        ]
-
-    @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
-
-    @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 output_tokens(self) -> None:
-        """Returns the number of output tokens."""
-        return None
-
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(self.input_tokens, self.output_tokens, self.model)
-
-    @computed_field
-    @property
-    def message_param(self) -> ContentDict:
-        """Returns the models's response as a message parameter."""
-        return {"role": "model", "parts": self.response.parts}  # type: ignore
-
-    @computed_field
-    @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
-
-    @computed_field
-    @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
-    def tool_message_params(
-        cls, tools_and_outputs: list[tuple[GeminiTool, object]]
-    ) -> list[FunctionResponse]:
-        """Returns the tool message parameters for tool call results.
-
-        Args:
-            tools_and_outputs: The list of tools and their outputs from which the tool
-                message parameters should be constructed.
-
-        Returns:
-            The list of constructed `FunctionResponse` parameters.
-        """
-        return [
-            FunctionResponse(name=tool._name(), response={"result": output})
-            for tool, output in tools_and_outputs
-        ]

mirascope/core/gemini/call_response_chunk.py

@@ -1,85 +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 (  # type: ignore
-    GenerateContentResponse,
-)
-
-from ..base import BaseCallResponseChunk
-
-
-class GeminiCallResponseChunk(
-    BaseCallResponseChunk[GenerateContentResponse, Candidate.FinishReason]
-):
-    """Convenience wrapper around chat completion streaming chunks.
-
-    When using Mirascope's convenience wrappers to interact with Gemini models via
-    `GeminiCall`, responses using `GeminiCall.stream()` will return a
-    `GeminiCallResponseChunk`, whereby the implemented properties allow for simpler
-    syntax and a convenient developer experience.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.gemini import gemini_call
-
-
-    @gemini_call("gemini-1.5-flash", stream=True)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    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 output_tokens(self) -> None:
-        """Returns the number of output tokens."""
-        return None

mirascope/core/gemini/dynamic_config.py

@@ -1,26 +0,0 @@
-"""This module defines the function return type for functions as LLM calls.
-
-usage docs: learn/dynamic_configuration.md#dynamic-configuration-options
-"""
-
-from google.generativeai.types import ContentsType  # type: ignore
-
-from ..base import BaseDynamicConfig
-from .call_params import GeminiCallParams
-
-GeminiDynamicConfig = BaseDynamicConfig[ContentsType, GeminiCallParams]
-"""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-flash-1.5")
-@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,121 +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,  # type: ignore
-)
-from google.generativeai.types import (  # type: ignore
-    GenerateContentResponse as GenerateContentResponseType,
-)
-from google.generativeai.types.content_types import PartType
-
-from ..base.stream import BaseStream
-from ._utils import calculate_cost
-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,
-        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)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # returns `GeminiStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "gemini"
-
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(self.input_tokens, self.output_tokens, self.model)
-
-    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,
-        )

mirascope/core/gemini/tool.py

@@ -1,104 +0,0 @@
-"""The `GeminiTool` class for easy tool usage with Google's Gemini LLM calls.
-
-usage docs: learn/tools.md#using-tools-with-standard-calls
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from google.ai.generativelanguage import FunctionCall
-from google.generativeai.types import (  # type: ignore
-    FunctionDeclaration,
-    Tool,
-)
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool
-
-
-class GeminiTool(BaseTool):
-    """A class for defining tools for Gemini LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.gemini import gemini_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @gemini_call("gemini-1.5-flash", tools=[format_book])
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `GeminiTool` instance
-        print(tool.call())
-    ```
-    """
-
-    tool_call: SkipJsonSchema[FunctionCall]
-
-    @classmethod
-    def tool_schema(cls) -> Tool:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.gemini import GeminiTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = GeminiTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Gemini-specific tool schema
-        ```
-        """
-        model_schema = cls.model_tool_schema()
-        fn: dict[str, Any] = {"name": cls._name(), "description": cls._description()}
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema  # type: ignore
-        if model_schema["required"]:
-            fn["parameters"]["required"] = model_schema["required"]
-        if "parameters" in fn:
-            if "$defs" in fn["parameters"]:
-                raise ValueError(
-                    "Unfortunately Google's Gemini API cannot handle nested structures "
-                    "with $defs."
-                )
-
-            def handle_enum_schema(prop_schema: dict[str, Any]) -> dict[str, Any]:
-                if "enum" in prop_schema:
-                    prop_schema["format"] = "enum"
-                return prop_schema
-
-            fn["parameters"]["properties"] = {
-                prop: {
-                    key: value
-                    for key, value in handle_enum_schema(prop_schema).items()
-                    if key != "default"
-                }
-                for prop, prop_schema in fn["parameters"]["properties"].items()
-            }
-        return Tool(function_declarations=[FunctionDeclaration(**fn)])
-
-    @classmethod
-    def from_tool_call(cls, tool_call: FunctionCall) -> GeminiTool:
-        """Constructs an `GeminiTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Gemini tool call from which to construct this tool instance.
-        """
-        if not tool_call.args:
-            raise ValueError("Tool call doesn't have any arguments.")
-        model_json: dict[str, Any] = dict(tool_call.args.items())
-        model_json["tool_call"] = tool_call
-        return cls.model_validate(model_json)

mirascope/core/groq/__init__.py

@@ -1,21 +0,0 @@
-"""The Mirascope Groq Module."""
-
-from ._call import groq_call
-from ._call import groq_call as call
-from .call_params import GroqCallParams
-from .call_response import GroqCallResponse
-from .call_response_chunk import GroqCallResponseChunk
-from .dynamic_config import GroqDynamicConfig
-from .stream import GroqStream
-from .tool import GroqTool
-
-__all__ = [
-    "call",
-    "GroqDynamicConfig",
-    "GroqCallParams",
-    "GroqCallResponse",
-    "GroqCallResponseChunk",
-    "GroqStream",
-    "GroqTool",
-    "groq_call",
-]