mirascope 1.25.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

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

mirascope/core/groq/_utils/_get_json_output.py

@@ -1,27 +0,0 @@
-"""Get the JSON output from a completion response."""
-
-from ..call_response import GroqCallResponse
-from ..call_response_chunk import GroqCallResponseChunk
-
-
-def get_json_output(
-    response: GroqCallResponse | GroqCallResponseChunk, json_mode: bool
-) -> str:
-    """Get the JSON output from a completion response."""
-    if isinstance(response, GroqCallResponse):
-        if json_mode and response.content:
-            return response.content
-        elif tool_calls := response.response.choices[0].message.tool_calls:
-            return tool_calls[0].function.arguments
-        raise ValueError("No tool call or JSON object found in response.")
-    else:
-        if json_mode:
-            return response.content
-        elif (
-            (choices := response.chunk.choices)
-            and (tool_calls := choices[0].delta.tool_calls)
-            and (function := tool_calls[0].function)
-            and (arguments := function.arguments) is not None
-        ):
-            return arguments
-        return ""

mirascope/core/groq/_utils/_handle_stream.py

@@ -1,123 +0,0 @@
-"""Handles the stream of completion chunks."""
-
-from collections.abc import AsyncGenerator, Generator
-
-from groq.types.chat import ChatCompletionChunk, ChatCompletionMessageToolCall
-from groq.types.chat.chat_completion_message_tool_call import Function
-
-from ..call_response_chunk import GroqCallResponseChunk
-from ..tool import GroqTool
-
-
-def _handle_chunk(
-    chunk: ChatCompletionChunk,
-    current_tool_call: ChatCompletionMessageToolCall,
-    current_tool_type: type[GroqTool] | None,
-    tool_types: list[type[GroqTool]] | None,
-) -> tuple[
-    GroqTool | None,
-    ChatCompletionMessageToolCall,
-    type[GroqTool] | None,
-]:
-    """Handles a chunk of the stream."""
-    if not tool_types or not (tool_calls := chunk.choices[0].delta.tool_calls):
-        return None, current_tool_call, current_tool_type
-
-    tool_call = tool_calls[0]
-    # Reset on new tool
-    if tool_call.id and tool_call.function is not None:
-        previous_tool_call = current_tool_call.model_copy()
-        previous_tool_type = current_tool_type
-        current_tool_call = ChatCompletionMessageToolCall(
-            id=tool_call.id,
-            function=Function(
-                arguments="",
-                name=tool_call.function.name if tool_call.function.name else "",
-            ),
-            type="function",
-        )
-        current_tool_type = None
-        for tool_type in tool_types:
-            if tool_type._name() == tool_call.function.name:
-                current_tool_type = tool_type
-                break
-        if current_tool_type is None:
-            raise RuntimeError(
-                f"Unknown tool type in stream: {tool_call.function.name}"
-            )  # pragma: no cover
-        if (
-            previous_tool_call.id
-            and previous_tool_call.function.arguments
-            and previous_tool_type is not None
-        ):
-            return (
-                previous_tool_type.from_tool_call(previous_tool_call),
-                current_tool_call,
-                current_tool_type,
-            )
-
-    # Update arguments with each chunk
-    if tool_call.function and tool_call.function.arguments:
-        current_tool_call.function.arguments += tool_call.function.arguments
-
-    return None, current_tool_call, current_tool_type
-
-
-def handle_stream(
-    stream: Generator[ChatCompletionChunk, None, None],
-    tool_types: list[type[GroqTool]] | None,
-    partial_tools: bool = False,
-) -> Generator[tuple[GroqCallResponseChunk, GroqTool | None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ChatCompletionMessageToolCall(
-        id="", function=Function(arguments="", name=""), type="function"
-    )
-    current_tool_type = None
-    for chunk in stream:
-        if not tool_types or not chunk.choices[0].delta.tool_calls:
-            if current_tool_type:
-                yield (
-                    GroqCallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield GroqCallResponseChunk(chunk=chunk), None
-        tool, current_tool_call, current_tool_type = _handle_chunk(
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-        )
-        if tool is not None:
-            yield GroqCallResponseChunk(chunk=chunk), tool
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[ChatCompletionChunk, None],
-    tool_types: list[type[GroqTool]] | None,
-    partial_tools: bool = False,
-) -> AsyncGenerator[tuple[GroqCallResponseChunk, GroqTool | None], None]:
-    """Async iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ChatCompletionMessageToolCall(
-        id="", function=Function(arguments="", name=""), type="function"
-    )
-    current_tool_type = None
-    async for chunk in stream:
-        if not tool_types or not chunk.choices[0].delta.tool_calls:
-            if current_tool_type:
-                yield (
-                    GroqCallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield GroqCallResponseChunk(chunk=chunk), None
-        tool, current_tool_call, current_tool_type = _handle_chunk(
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-        )
-        if tool is not None:
-            yield GroqCallResponseChunk(chunk=chunk), tool

mirascope/core/groq/_utils/_message_param_converter.py

@@ -1,89 +0,0 @@
-import json
-from typing import cast
-
-from groq.types.chat import ChatCompletionMessageParam
-
-from mirascope.core import BaseMessageParam
-from mirascope.core.base import TextPart, ToolResultPart
-from mirascope.core.base._utils._base_message_param_converter import (
-    BaseMessageParamConverter,
-)
-from mirascope.core.base.message_param import ImageURLPart, ToolCallPart
-from mirascope.core.groq._utils import convert_message_params
-
-
-class GroqMessageParamConverter(BaseMessageParamConverter):
-    """Converts between Groq `ChatCompletionMessageParam` and Mirascope `BaseMessageParam`."""
-
-    @staticmethod
-    def to_provider(
-        message_params: list[BaseMessageParam],
-    ) -> list[ChatCompletionMessageParam]:
-        """
-        Convert from Mirascope `BaseMessageParam` to Groq `ChatCompletionMessageParam`.
-        """
-        return convert_message_params(
-            cast(list[BaseMessageParam | ChatCompletionMessageParam], message_params)
-        )
-
-    @staticmethod
-    def from_provider(
-        message_params: list[ChatCompletionMessageParam],
-    ) -> list[BaseMessageParam]:
-        """Convert from Groq's `ChatCompletionAssistantMessageParam` to Mirascope `BaseMessageParam`."""
-        converted = []
-        for message_param in message_params:
-            contents = []
-            content = message_param.get("content")
-            if message_param["role"] == "tool":
-                converted.append(
-                    BaseMessageParam(
-                        role="tool",
-                        content=[
-                            ToolResultPart(
-                                type="tool_result",
-                                name=getattr(message_param, "name", ""),
-                                content=message_param["content"],
-                                id=message_param["tool_call_id"],
-                                is_error=False,
-                            )
-                        ],
-                    )
-                )
-                continue
-            if tool_calls := message_param.get("tool_calls"):
-                for tool_call in tool_calls:
-                    contents.append(
-                        ToolCallPart(
-                            type="tool_call",
-                            name=tool_call["function"]["name"],
-                            id=tool_call["id"],
-                            args=json.loads(tool_call["function"]["arguments"]),
-                        )
-                    )
-            elif isinstance(content, str):
-                converted.append(
-                    BaseMessageParam(role=message_param["role"], content=content)
-                )
-                continue
-            elif isinstance(content, list):
-                for part in content:
-                    if "text" in part:
-                        contents.append(TextPart(type="text", text=part["text"]))
-                    elif "image_url" in part:
-                        contents.append(
-                            ImageURLPart(
-                                type="image_url",
-                                url=part["image_url"]["url"],
-                                detail=part["image_url"].get("detail"),
-                            )
-                        )
-            if contents:
-                converted.append(
-                    BaseMessageParam(role=message_param["role"], content=contents)
-                )
-            else:
-                converted.append(
-                    BaseMessageParam(role=message_param["role"], content="")
-                )
-        return converted