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

mirascope/core/groq/_call.py

@@ -1,71 +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 .dynamic_config import GroqDynamicConfig
-from .stream import GroqStream
-from .tool import GroqTool
-
-groq_call = call_factory(
-    TCallResponse=GroqCallResponse,
-    TCallResponseChunk=GroqCallResponseChunk,
-    TDynamicConfig=GroqDynamicConfig,
-    TToolType=GroqTool,
-    TStream=GroqStream,
-    TCallParams=GroqCallParams,
-    default_call_params=GroqCallParams(),
-    setup_call=setup_call,  # type: ignore
-    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 docstring 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")
-@prompt_template("Recommend a {genre} book")
-def recommend_book(genre: str):
-    ...
-
-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/_utils/__init__.py

@@ -1,16 +0,0 @@
-"""Groq utilities for decorator factories."""
-
-from ._calculate_cost import calculate_cost
-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__ = [
-    "calculate_cost",
-    "convert_message_params",
-    "get_json_output",
-    "handle_stream",
-    "handle_stream_async",
-    "setup_call",
-]

mirascope/core/groq/_utils/_calculate_cost.py

@@ -1,68 +0,0 @@
-"""Calculate the cost of a completion using the Groq API."""
-
-
-def calculate_cost(
-    input_tokens: int | float | None,
-    output_tokens: int | float | None,
-    model: str = "mixtral-8x7b-32768",
-) -> float | None:
-    """Calculate the cost of a completion using the Groq API.
-
-    https://wow.groq.com/
-
-    Model                                  Input               Output
-    llama-3.1-405b-reasoning               N/A                 N/A
-    llama-3.1-70b-versatile                N/A                 N/A
-    llama-3.1-8b-instant                   N/A                 N/A
-    llama3-groq-70b-8192-tool-use-preview  $0.89 / 1M tokens   $0.89 / 1M tokens
-    llama3-groq-8b-8192-tool-use-preview   $0.19 / 1M tokens   $0.19 / 1M tokens
-    llama3-70b-8192                        $0.59 / 1M tokens   $0.79 / 1M tokens
-    llama3-8b-8192                         $0.05 / 1M tokens   $0.08 / 1M tokens
-    mixtral-8x7b-32768                     $0.27 / 1M tokens   $0.27 / 1M tokens
-    gemma-7b-it                            $0.07 / 1M tokens   $0.07 / 1M tokens
-    gemma2-9b-it                           $0.20 / 1M tokens   $0.20 / 1M tokens
-    """
-    pricing = {
-        "llama3-groq-70b-8192-tool-use-preview": {
-            "prompt": 0.000_000_89,
-            "completion": 0.000_000_89,
-        },
-        "llama3-groq-8b-8192-tool-use-preview": {
-            "prompt": 0.000_000_19,
-            "completion": 0.000_000_19,
-        },
-        "llama3-70b-8192": {
-            "prompt": 0.000_000_59,
-            "completion": 0.000_000_79,
-        },
-        "llama3-8b-8192": {
-            "prompt": 0.000_000_05,
-            "completion": 0.000_000_08,
-        },
-        "mixtral-8x7b-32768": {
-            "prompt": 0.000_000_24,
-            "completion": 0.000_000_24,
-        },
-        "gemma-7b-it": {
-            "prompt": 0.000_000_07,
-            "completion": 0.000_000_07,
-        },
-        "gemma2-9b-it": {
-            "prompt": 0.000_000_2,
-            "completion": 0.000_000_2,
-        },
-    }
-
-    if input_tokens is None or output_tokens is None:
-        return None
-
-    try:
-        model_pricing = pricing[model]
-    except KeyError:
-        return None
-
-    prompt_cost = input_tokens * model_pricing["prompt"]
-    completion_cost = output_tokens * model_pricing["completion"]
-    total_cost = prompt_cost + completion_cost
-
-    return total_cost

mirascope/core/groq/_utils/_convert_message_params.py

@@ -1,23 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ChatCompletionMessageParam`"""
-
-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:
-            if len(content) != 1 or content[0].type != "text":
-                raise ValueError("Groq does not currently support multimodalities.")
-            converted_message_params.append(
-                {"role": message_param.role, "content": content[0].text}
-            )
-    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,121 +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,
-) -> 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,
-) -> 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/_setup_call.py

@@ -1,67 +0,0 @@
-"""This module contains the setup_call function for Groq tools."""
-
-import inspect
-from collections.abc import Awaitable, Callable
-from typing import Any, cast
-
-from groq import AsyncGroq, Groq
-from groq.types.chat import ChatCompletion, ChatCompletionMessageParam
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ..call_params import GroqCallParams
-from ..dynamic_config import GroqDynamicConfig
-from ..tool import GroqTool
-from ._convert_message_params import convert_message_params
-
-
-def setup_call(
-    *,
-    model: str,
-    client: Groq | AsyncGroq | None,
-    fn: Callable[..., GroqDynamicConfig | Awaitable[GroqDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: GroqDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GroqCallParams,
-    extract: bool,
-) -> tuple[
-    Callable[..., ChatCompletion] | Callable[..., Awaitable[ChatCompletion]],
-    str,
-    list[ChatCompletionMessageParam],
-    list[type[GroqTool]] | None,
-    dict[str, Any],
-]:
-    prompt_template, messages, tool_types, call_kwargs = _utils.setup_call(
-        fn, fn_args, dynamic_config, tools, GroqTool, call_params
-    )
-    messages = cast(list[BaseMessageParam | ChatCompletionMessageParam], messages)
-    messages = convert_message_params(messages)
-    if json_mode:
-        call_kwargs["response_format"] = {"type": "json_object"}
-        json_mode_content = _utils.json_mode_content(
-            tool_types[0] if tool_types else None
-        )
-        if messages[-1]["role"] == "user":
-            if isinstance(messages[-1]["content"], str):
-                messages[-1]["content"] += json_mode_content
-            else:
-                messages[-1]["content"] = list(messages[-1]["content"]) + [
-                    {"type": "text", "text": json_mode_content.strip()}
-                ]
-        else:
-            messages.append({"role": "user", "content": json_mode_content.strip()})
-        call_kwargs.pop("tools", None)
-    elif extract:
-        assert tool_types, "At least one tool must be provided for extraction."
-        call_kwargs["tool_choice"] = {
-            "type": "function",
-            "function": {"name": tool_types[0]._name()},
-        }
-    call_kwargs |= {"model": model, "messages": messages}
-
-    if client is None:
-        client = AsyncGroq() if inspect.iscoroutinefunction(fn) else Groq()
-    create = client.chat.completions.create
-
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/groq/call_params.py

@@ -1,51 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from groq.types.chat.chat_completion_tool_choice_option_param import (
-    ChatCompletionToolChoiceOptionParam,
-)
-from groq.types.chat.completion_create_params import ResponseFormat
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-
-class GroqCallParams(BaseCallParams):
-    """The parameters to use when calling the Groq API.
-
-    [Groq API Reference](https://console.groq.com/docs/api-reference#chat-create)
-
-    Attributes:
-        frequency_penalty: ...
-        logit_bias: ...
-        logprobs: ...
-        max_tokens: ...
-        n: ...
-        parallel_tool_calls: ...
-        presence_penalty: ...
-        response_format: ...
-        seed: ...
-        stop: ...
-        temperature: ...
-        tool_choice: ...
-        top_logprobs: ...
-        top_p: ...
-        user: ...
-    """
-
-    frequency_penalty: NotRequired[float | None]
-    logit_bias: NotRequired[dict[str, int] | None]
-    logprobs: NotRequired[bool | None]
-    max_tokens: NotRequired[int | None]
-    n: NotRequired[int | None]
-    parallel_tool_calls: NotRequired[bool]
-    presence_penalty: NotRequired[float | None]
-    response_format: NotRequired[ResponseFormat]
-    seed: NotRequired[int | None]
-    stop: NotRequired[str | list[str] | None]
-    temperature: NotRequired[float | None]
-    tool_choice: NotRequired[ChatCompletionToolChoiceOptionParam]
-    top_logprobs: NotRequired[int | None]
-    top_p: NotRequired[float | None]
-    user: NotRequired[str]

mirascope/core/groq/call_response.py

@@ -1,160 +0,0 @@
-"""This module contains the `GroqCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from groq.types.chat import (
-    ChatCompletion,
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionMessageParam,
-    ChatCompletionToolMessageParam,
-    ChatCompletionUserMessageParam,
-)
-from groq.types.completion_usage import CompletionUsage
-from pydantic import SerializeAsAny, computed_field
-
-from ..base import BaseCallResponse
-from ._utils import calculate_cost
-from .call_params import GroqCallParams
-from .dynamic_config import GroqDynamicConfig
-from .tool import GroqTool
-
-
-class GroqCallResponse(
-    BaseCallResponse[
-        ChatCompletion,
-        GroqTool,
-        GroqDynamicConfig,
-        ChatCompletionMessageParam,
-        GroqCallParams,
-        ChatCompletionUserMessageParam,
-    ]
-):
-    """A convenience wrapper around the Groq `ChatCompletion` response.
-
-    When calling the Groq API using a function decorated with `groq_call`, the
-    response will be an `GroqCallResponse` instance with properties that allow for
-    more convenience access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.groq import groq_call
-
-
-    @groq_call("llama-3.1-8b-instant")
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")  # response is an `GroqCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _provider = "groq"
-
-    @property
-    def content(self) -> str:
-        """Returns the content of the chat completion for the 0th choice."""
-        message = self.response.choices[0].message
-        return message.content if message.content is not None else ""
-
-    @property
-    def finish_reasons(self) -> list[str]:
-        """Returns the finish reasons of the response."""
-        return [str(choice.finish_reason) for choice in self.response.choices]
-
-    @property
-    def model(self) -> str:
-        """Returns the name of the response model."""
-        return self.response.model
-
-    @property
-    def id(self) -> str:
-        """Returns the id of the response."""
-        return self.response.id
-
-    @property
-    def usage(self) -> CompletionUsage | None:
-        """Returns the usage of the chat completion."""
-        return self.response.usage
-
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        return self.usage.prompt_tokens if self.usage else None
-
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        return self.usage.completion_tokens if self.usage else 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) -> SerializeAsAny[ChatCompletionAssistantMessageParam]:
-        """Returns the assistants's response as a message parameter."""
-        return self.response.choices[0].message.model_dump(exclude={"function_call"})  # type: ignore
-
-    @computed_field
-    @property
-    def tools(self) -> list[GroqTool] | None:
-        """Returns any available tool calls as their `GroqTool` definition.
-
-        Raises:
-            ValidationError: if a tool call doesn't match the tool's schema.
-        """
-        tool_calls = self.response.choices[0].message.tool_calls
-        if not self.tool_types or not tool_calls:
-            return None
-
-        extracted_tools = []
-        for tool_call in tool_calls:
-            for tool_type in self.tool_types:
-                if tool_call.function.name == tool_type._name():
-                    extracted_tools.append(tool_type.from_tool_call(tool_call))
-                    break
-
-        return extracted_tools
-
-    @computed_field
-    @property
-    def tool(self) -> GroqTool | None:
-        """Returns the 0th tool for the 0th choice message.
-
-        Raises:
-            ValidationError: if the tool call doesn't match the tool's schema.
-        """
-        if tools := self.tools:
-            return tools[0]
-        return None
-
-    @classmethod
-    def tool_message_params(
-        cls, tools_and_outputs: list[tuple[GroqTool, str]]
-    ) -> list[ChatCompletionToolMessageParam]:
-        """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 `ChatCompletionToolMessageParam` parameters.
-        """
-        return [
-            ChatCompletionToolMessageParam(
-                role="tool",
-                content=output,
-                tool_call_id=tool.tool_call.id,
-                name=tool._name(),  # type: ignore
-            )
-            for tool, output in tools_and_outputs
-        ]