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

mirascope/core/google/call_response_chunk.py

@@ -1,110 +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."""
-        return self.chunk.candidates[0].content.parts[0].text  # pyright: ignore [reportOptionalMemberAccess, reportOptionalSubscript, reportReturnType]
-
-    @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,143 +0,0 @@
-"""The `GoogleStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from typing import cast
-
-from google.genai.types import (
-    Candidate,
-    Content,
-    ContentDict,
-    ContentListUnion,
-    ContentListUnionDict,
-    FinishReason,
-    FunctionCall,
-    GenerateContentResponse,
-    GenerateContentResponseUsageMetadata,
-    PartDict,
-    Tool,
-)
-
-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 _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
-        )
-        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=self.message_param["parts"],  # pyright: ignore [reportTypedDictNotRequiredAccess, 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

mirascope/core/google/tool.py

@@ -1,146 +0,0 @@
-"""The `GoogleTool` class for easy tool usage with Google's Google LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from google.genai.types import (
-    FunctionCall,
-    FunctionDeclaration,
-    Tool,
-)
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool
-
-
-class GoogleTool(BaseTool):
-    """A class for defining tools for Google LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.google import google_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @google_call("google-1.5-flash", tools=[format_book])
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `GoogleTool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "google"
-
-    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.google import GoogleTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = GoogleTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Google-specific tool schema
-        ```
-        """
-        model_schema = cls.model_json_schema()
-        fn: dict[str, Any] = {"name": cls._name(), "description": cls._description()}
-
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema
-
-        if "parameters" in fn:
-            # Define a function to handle both ref resolution and examples conversion
-            def resolve_refs_and_fix_examples(
-                schema: dict[str, Any], defs: dict[str, Any] | None = None
-            ) -> dict[str, Any]:
-                """Recursively resolve $ref references and fix examples/example fields."""
-                # If this is a reference, resolve it
-                if "$ref" in schema:
-                    ref = schema["$ref"]
-                    if ref.startswith("#/$defs/") and defs:
-                        ref_key = ref.replace("#/$defs/", "")
-                        if ref_key in defs:
-                            # Merge the definition with the current schema (excluding $ref)
-                            resolved = {
-                                **{k: v for k, v in schema.items() if k != "$ref"},
-                                **resolve_refs_and_fix_examples(defs[ref_key], defs),
-                            }
-                            return resolved
-
-                # Handle examples -> example conversion
-                result = {}
-                for key, value in schema.items():
-                    # Convert "examples" to "example" for Google Schema
-                    if key == "examples":
-                        result["example"] = value
-                    elif isinstance(value, dict):
-                        result[key] = resolve_refs_and_fix_examples(value, defs)
-                    elif isinstance(value, list):
-                        result[key] = [
-                            resolve_refs_and_fix_examples(item, defs)
-                            if isinstance(item, dict)
-                            else item
-                            for item in value
-                        ]
-                    else:
-                        result[key] = value
-                return result
-
-            # Extract $defs if they exist
-            defs = {}
-            if "$defs" in fn["parameters"]:
-                defs = fn["parameters"].pop("$defs")
-
-            # Resolve all references in the parameters and fix examples
-            fn["parameters"] = resolve_refs_and_fix_examples(fn["parameters"], 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
-
-            # Process properties after resolving references
-            # We're already handling examples -> example conversion recursively above
-            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) -> GoogleTool:
-        """Constructs an `GoogleTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Google tool call from which to construct this tool instance.
-        """
-        model_json = {"tool_call": tool_call}
-        if tool_call.args:
-            model_json |= dict(tool_call.args.items())
-        return cls.model_validate(model_json)

mirascope/core/groq/__init__.py

@@ -1,30 +0,0 @@
-"""The Mirascope Groq Module."""
-
-from typing import TypeAlias
-
-from groq.types.chat import ChatCompletionMessageParam
-
-from ..base import BaseMessageParam
-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 AsyncGroqDynamicConfig, GroqDynamicConfig
-from .stream import GroqStream
-from .tool import GroqTool
-
-GroqMessageParam: TypeAlias = ChatCompletionMessageParam | BaseMessageParam
-
-__all__ = [
-    "AsyncGroqDynamicConfig",
-    "GroqCallParams",
-    "GroqCallResponse",
-    "GroqCallResponseChunk",
-    "GroqDynamicConfig",
-    "GroqMessageParam",
-    "GroqStream",
-    "GroqTool",
-    "call",
-    "groq_call",
-]

mirascope/core/groq/_call.py

@@ -1,67 +0,0 @@
-"""The `groq_call` decorator for functions as LLM calls."""
-
-from ..base import call_factory
-from ._utils import (
-    get_json_output,
-    handle_stream,
-    handle_stream_async,
-    setup_call,
-)
-from .call_params import GroqCallParams
-from .call_response import GroqCallResponse
-from .call_response_chunk import GroqCallResponseChunk
-from .stream import GroqStream
-from .tool import GroqTool
-
-groq_call = call_factory(
-    TCallResponse=GroqCallResponse,
-    TCallResponseChunk=GroqCallResponseChunk,
-    TToolType=GroqTool,
-    TStream=GroqStream,
-    default_call_params=GroqCallParams(),
-    setup_call=setup_call,
-    get_json_output=get_json_output,
-    handle_stream=handle_stream,
-    handle_stream_async=handle_stream_async,
-)
-"""A decorator for calling the Groq API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Groq API. It parses
-the prompt template of the wrapped function as the messages array and templates the input
-arguments for the function into each message's template.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.groq import groq_call
-
-
-@groq_call("llama-3.1-8b-instant")
-def recommend_book(genre: str) -> str:
-    return f"Recommend a {genre} book"
-
-response = recommend_book("fantasy")
-print(response.content)
-```
-
-Args:
-    model (str): The Groq model to use in the API call.
-    stream (bool): Whether to stream the response from the API call.
-    tools (list[BaseTool | Callable]): The tools to use in the Groq API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[CohereCallResponse | ResponseModelT], Any]): A function for
-        parsing the call response whose value will be returned in place of the original
-        call response.
-    json_mode (bool): Whether to use JSON Mode.
-    client (object): An optional custom client to use in place of the default client.
-    call_params (GroqCallParams): The `GroqCallParams` call parameters to use in the API
-        call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a Groq API
-        call.
-"""

mirascope/core/groq/_call_kwargs.py

@@ -1,13 +0,0 @@
-"""This module contains the type definition for the Groq call keyword arguments."""
-
-from collections.abc import Sequence
-
-from groq.types.chat import ChatCompletionMessageParam, ChatCompletionToolParam
-
-from ..base import BaseCallKwargs
-from .call_params import GroqCallParams
-
-
-class GroqCallKwargs(GroqCallParams, BaseCallKwargs[ChatCompletionToolParam]):
-    model: str
-    messages: Sequence[ChatCompletionMessageParam]

mirascope/core/groq/_utils/__init__.py

@@ -1,14 +0,0 @@
-"""Groq utilities for decorator factories."""
-
-from ._convert_message_params import convert_message_params
-from ._get_json_output import get_json_output
-from ._handle_stream import handle_stream, handle_stream_async
-from ._setup_call import setup_call
-
-__all__ = [
-    "convert_message_params",
-    "get_json_output",
-    "handle_stream",
-    "handle_stream_async",
-    "setup_call",
-]

mirascope/core/groq/_utils/_convert_common_call_params.py

@@ -1,26 +0,0 @@
-from typing import cast
-
-from ...base.call_params import CommonCallParams
-from ..call_params import GroqCallParams
-
-GROQ_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "max_tokens",
-    "top_p": "top_p",
-    "frequency_penalty": "frequency_penalty",
-    "presence_penalty": "presence_penalty",
-    "seed": "seed",
-    "stop": "stop",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> GroqCallParams:
-    """Convert CommonCallParams to Groq parameters."""
-    return cast(
-        GroqCallParams,
-        {
-            GROQ_PARAM_MAPPING[key]: value
-            for key, value in common_params.items()
-            if key in GROQ_PARAM_MAPPING and value is not None
-        },
-    )

mirascope/core/groq/_utils/_convert_message_params.py

@@ -1,112 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ChatCompletionMessageParam`"""
-
-import base64
-import json
-
-from groq.types.chat import (
-    ChatCompletionMessageParam,
-)
-
-from ...base import BaseMessageParam
-
-
-def convert_message_params(
-    message_params: list[BaseMessageParam | ChatCompletionMessageParam],
-) -> list[ChatCompletionMessageParam]:
-    converted_message_params = []
-    for message_param in message_params:
-        if not isinstance(message_param, BaseMessageParam):
-            converted_message_params.append(message_param)
-        elif isinstance(content := message_param.content, str):
-            converted_message_params.append(message_param.model_dump())
-        else:
-            converted_content = []
-            for part in content:
-                if part.type == "text":
-                    converted_content.append(part.model_dump())
-                elif part.type == "image":
-                    if part.media_type not in [
-                        "image/jpeg",
-                        "image/png",
-                        "image/gif",
-                        "image/webp",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported image media type: {part.media_type}. Groq"
-                            " currently only supports JPEG, PNG, GIF, and WebP images."
-                        )
-                    data = base64.b64encode(part.image).decode("utf-8")
-                    converted_content.append(
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:{part.media_type};base64,{data}",
-                                "detail": part.detail if part.detail else "auto",
-                            },
-                        }
-                    )
-                elif part.type == "image_url":
-                    converted_content.append(
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": part.url,
-                            },
-                        }
-                    )
-                elif part.type == "tool_call":
-                    converted_message_param = {
-                        "role": "assistant",
-                        "tool_calls": [
-                            {
-                                "type": "function",
-                                "id": part.id,
-                                "function": {
-                                    "name": part.name,
-                                    "arguments": json.dumps(part.args),
-                                },
-                            }
-                        ],
-                    }
-                    if converted_content:
-                        if len(converted_content) == 1:
-                            if converted_content[0]["type"] == "text":
-                                converted_message_param["content"] = converted_content[
-                                    0
-                                ]["text"]
-                        else:
-                            converted_message_params.append(
-                                {
-                                    "role": message_param.role,
-                                    "content": converted_content,
-                                }
-                            )
-                        converted_content = []
-                    converted_message_params.append(converted_message_param)
-
-                elif part.type == "tool_result":
-                    if converted_content:
-                        converted_message_params.append(
-                            {
-                                "role": message_param.role,
-                                "content": converted_content,
-                            }
-                        )
-                        converted_content = []
-                    converted_message_params.append(
-                        {
-                            "role": "tool",
-                            "content": part.content,
-                            "tool_call_id": part.id,
-                        }
-                    )
-                else:
-                    raise ValueError(
-                        "Groq currently only supports text and image parts. "
-                        f"Part provided: {part.type}"
-                    )
-            if converted_content:
-                converted_message_params.append(
-                    {"role": message_param.role, "content": converted_content}
-                )
-    return converted_message_params