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

mirascope/core/groq/_utils/_setup_call.py

@@ -1,132 +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, overload
-
-from groq import AsyncGroq, Groq
-from groq.types.chat import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ChatCompletionMessageParam,
-)
-from pydantic import BaseModel
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ...base._utils import AsyncCreateFn, CreateFn, get_async_create_fn, get_create_fn
-from ...base.call_params import CommonCallParams
-from ...base.stream_config import StreamConfig
-from .._call_kwargs import GroqCallKwargs
-from ..call_params import GroqCallParams
-from ..dynamic_config import AsyncGroqDynamicConfig, GroqDynamicConfig
-from ..tool import GroqTool
-from ._convert_common_call_params import convert_common_call_params
-from ._convert_message_params import convert_message_params
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: AsyncGroq | None,
-    fn: Callable[..., Awaitable[AsyncGroqDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: AsyncGroqDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GroqCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[ChatCompletion, ChatCompletionChunk],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[GroqTool]] | None,
-    GroqCallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: Groq | None,
-    fn: Callable[..., GroqDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: GroqDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GroqCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletion, ChatCompletionChunk],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[GroqTool]] | None,
-    GroqCallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: Groq | AsyncGroq | None,
-    fn: Callable[..., GroqDynamicConfig | Awaitable[AsyncGroqDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: GroqDynamicConfig | AsyncGroqDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: GroqCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletion, ChatCompletionChunk]
-    | AsyncCreateFn[ChatCompletion, ChatCompletionChunk],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[GroqTool]] | None,
-    GroqCallKwargs,
-]:
-    prompt_template, messages, tool_types, base_call_kwargs = _utils.setup_call(
-        fn,
-        fn_args,
-        dynamic_config,
-        tools,
-        GroqTool,
-        call_params,
-        convert_common_call_params,
-    )
-    call_kwargs = cast(GroqCallKwargs, base_call_kwargs)
-    messages = cast(list[BaseMessageParam | ChatCompletionMessageParam], messages)
-    messages = convert_message_params(messages)
-    if json_mode:
-        if not tools:
-            call_kwargs["response_format"] = {"type": "json_object"}
-        json_mode_content = _utils.json_mode_content(response_model)
-        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()})
-    elif response_model:
-        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 = (
-        get_async_create_fn(client.chat.completions.create)
-        if isinstance(client, AsyncGroq)
-        else get_create_fn(client.chat.completions.create)
-    )
-
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/groq/call_params.py

@@ -1,52 +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: ...
-    """
-
-    extra_headers: NotRequired[dict[str, str] | None]
-    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,213 +0,0 @@
-"""This module contains the `GroqCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-from typing import cast
-
-from groq.types.chat import (
-    ChatCompletion,
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionMessageParam,
-    ChatCompletionToolMessageParam,
-    ChatCompletionToolParam,
-    ChatCompletionUserMessageParam,
-)
-from groq.types.completion_usage import CompletionUsage
-from pydantic import SerializeAsAny, computed_field
-
-from .. import BaseMessageParam
-from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import CostMetadata, FinishReason, ImageMetadata
-from ._utils._message_param_converter import GroqMessageParamConverter
-from .call_params import GroqCallParams
-from .dynamic_config import AsyncGroqDynamicConfig, GroqDynamicConfig
-from .tool import GroqTool
-
-
-class GroqCallResponse(
-    BaseCallResponse[
-        ChatCompletion,
-        GroqTool,
-        ChatCompletionToolParam,
-        AsyncGroqDynamicConfig | GroqDynamicConfig,
-        ChatCompletionMessageParam,
-        GroqCallParams,
-        ChatCompletionUserMessageParam,
-        GroqMessageParamConverter,
-    ]
-):
-    """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")
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-    response = recommend_book("fantasy")  # response is an `GroqCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _message_converter: type[GroqMessageParamConverter] = GroqMessageParamConverter
-
-    _provider = "groq"
-
-    @computed_field
-    @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 ""
-
-    @computed_field
-    @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]
-
-    @computed_field
-    @property
-    def model(self) -> str:
-        """Returns the name of the response model."""
-        return self.response.model
-
-    @computed_field
-    @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
-
-    @computed_field
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        return self.usage.prompt_tokens if self.usage else None
-
-    @computed_field
-    @property
-    def cached_tokens(self) -> int | None:
-        """Returns the number of cached tokens."""
-        return 0
-
-    @computed_field
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        return self.usage.completion_tokens if self.usage else None
-
-    @computed_field
-    @cached_property
-    def message_param(self) -> SerializeAsAny[ChatCompletionAssistantMessageParam]:
-        """Returns the assistants's response as a message parameter."""
-        message_param = self.response.choices[0].message.model_dump(
-            exclude={"function_call"}
-        )
-        return ChatCompletionAssistantMessageParam(**message_param)
-
-    @cached_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
-
-    @cached_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
-    @transform_tool_outputs
-    def tool_message_params(
-        cls, tools_and_outputs: Sequence[tuple[GroqTool, str]]
-    ) -> list[ChatCompletionToolMessageParam]:
-        """Returns the tool message parameters for tool call results.
-
-        Args:
-            tools_and_outputs: The sequence of tools and their outputs from which the tool
-                message parameters should be constructed.
-
-        Returns:
-            The list of constructed `ChatCompletionToolMessageParam` parameters.
-        """
-        return [
-            ChatCompletionToolMessageParam(  # pyright: ignore [reportCallIssue]
-                role="tool",
-                content=output,
-                tool_call_id=tool.tool_call.id,  # pyright: ignore [reportOptionalMemberAccess]
-                name=tool._name(),  # pyright: ignore [reportCallIssue]
-            )
-            for tool, output in tools_and_outputs
-        ]
-
-    @property
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        return cast(list[FinishReason], self.finish_reasons)
-
-    @property
-    def common_message_param(self) -> BaseMessageParam:
-        return GroqMessageParamConverter.from_provider([self.message_param])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return GroqMessageParamConverter.from_provider([self.user_message_param])[0]
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        cost_metadata = super().cost_metadata
-        image_metadata = []
-
-        for message in self.messages:
-            if "content" not in message:
-                continue
-            content = message["content"]
-
-            if not isinstance(content, list):
-                continue
-            for part in content:
-                # Check if this part is an image_url
-                if isinstance(part, dict) and part.get("type") == "image_url":
-                    # Only count the image if it has a URL
-                    image_metadata.append(ImageMetadata(width=0, height=0))
-
-        cost_metadata.images = image_metadata
-        return cost_metadata

mirascope/core/groq/call_response_chunk.py

@@ -1,104 +0,0 @@
-"""This module contains the `GroqCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from typing import cast
-
-from groq.types.chat import ChatCompletionChunk
-from groq.types.chat.chat_completion import Choice
-from groq.types.completion_usage import CompletionUsage
-
-from ..base import BaseCallResponseChunk
-from ..base.types import CostMetadata
-
-FinishReason = Choice.__annotations__["finish_reason"]
-
-
-class GroqCallResponseChunk(BaseCallResponseChunk[ChatCompletionChunk, FinishReason]):
-    """A convenience wrapper around the Groq `ChatCompletionChunk` streamed chunks.
-
-    When calling the Groq API using a function decorated with `groq_call` and
-    `stream` set to `True`, the stream will contain `GroqResponseChunk` instances with
-    properties that allow for more convenient 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", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-    stream = recommend_book("fantasy")  # response is an `GroqStream`
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    @property
-    def content(self) -> str:
-        """Returns the content for the 0th choice delta."""
-        delta = None
-        if self.chunk.choices:
-            delta = self.chunk.choices[0].delta
-        return delta.content if delta is not None and delta.content else ""
-
-    @property
-    def finish_reasons(
-        self,
-    ) -> list[FinishReason]:
-        """Returns the finish reasons of the response."""
-        return [
-            choice.finish_reason
-            for choice in self.chunk.choices
-            if choice.finish_reason
-        ]
-
-    @property
-    def model(self) -> str:
-        """Returns the name of the response model."""
-        return self.chunk.model
-
-    @property
-    def id(self) -> str:
-        """Returns the id of the response."""
-        return self.chunk.id
-
-    @property
-    def usage(self) -> CompletionUsage | None:
-        """Returns the usage of the chat completion."""
-        if self.chunk.usage:
-            return self.chunk.usage
-        return None
-
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        if self.usage:
-            return self.usage.prompt_tokens
-        return None
-
-    @property
-    def cached_tokens(self) -> int | None:
-        """Returns the number of cached tokens."""
-        return 0
-
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        if self.usage:
-            return self.usage.completion_tokens
-        return None
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Returns the cost metadata."""
-        return super().cost_metadata
-
-    @property
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        return cast(list[FinishReason], self.finish_reasons)

mirascope/core/groq/dynamic_config.py

@@ -1,29 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from groq import AsyncGroq, Groq
-from groq.types.chat import ChatCompletionMessageParam
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import GroqCallParams
-
-AsyncGroqDynamicConfig = BaseDynamicConfig[
-    ChatCompletionMessageParam | BaseMessageParam, GroqCallParams, AsyncGroq
-]
-GroqDynamicConfig = BaseDynamicConfig[
-    ChatCompletionMessageParam | BaseMessageParam, GroqCallParams, Groq
-]
-"""The function return type for functions wrapped with the `groq_call` decorator.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.groq import GroqDynamicConfig, groq_call
-
-
-@groq_call("llama-3.1-8b-instant")
-@prompt_template("Recommend a {capitalized_genre} book")
-def recommend_book(genre: str) -> GroqDynamicConfig:
-    return {"computed_fields": {"capitalized_genre": genre.capitalize()}}
-```
-"""

mirascope/core/groq/stream.py

@@ -1,135 +0,0 @@
-"""The `GroqStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from groq.types.chat import (
-    ChatCompletion,
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionMessageParam,
-    ChatCompletionMessageToolCallParam,
-    ChatCompletionToolMessageParam,
-    ChatCompletionToolParam,
-    ChatCompletionUserMessageParam,
-)
-from groq.types.chat.chat_completion import Choice
-from groq.types.chat.chat_completion_message import ChatCompletionMessage
-from groq.types.completion_usage import CompletionUsage
-
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from .call_params import GroqCallParams
-from .call_response import GroqCallResponse
-from .call_response_chunk import GroqCallResponseChunk
-from .dynamic_config import AsyncGroqDynamicConfig, GroqDynamicConfig
-from .tool import GroqTool
-
-FinishReason = Choice.__annotations__["finish_reason"]
-
-
-class GroqStream(
-    BaseStream[
-        GroqCallResponse,
-        GroqCallResponseChunk,
-        ChatCompletionUserMessageParam,
-        ChatCompletionAssistantMessageParam,
-        ChatCompletionToolMessageParam,
-        ChatCompletionMessageParam,
-        GroqTool,
-        ChatCompletionToolParam,
-        AsyncGroqDynamicConfig | GroqDynamicConfig,
-        GroqCallParams,
-        FinishReason,
-    ]
-):
-    """A class for convenience around streaming Groq LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.groq import groq_call
-
-
-    @groq_call("llama-3.1-8b-instant", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-    stream = recommend_book("fantasy")  # returns `GroqStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "groq"
-
-    def _construct_message_param(
-        self,
-        tool_calls: list[ChatCompletionMessageToolCallParam] | None = None,
-        content: str | None = None,
-    ) -> ChatCompletionAssistantMessageParam:
-        message_param = ChatCompletionAssistantMessageParam(
-            role="assistant",
-            content=content,
-        )
-        if tool_calls:
-            message_param["tool_calls"] = tool_calls
-        return message_param
-
-    def construct_call_response(self) -> GroqCallResponse:
-        """Constructs the call response from a consumed GroqStream.
-
-        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."
-            )
-        message = {
-            "role": self.message_param["role"],
-            "content": self.message_param.get("content", ""),
-            "tool_calls": self.message_param.get("tool_calls", []),
-        }
-        if not self.input_tokens and not self.output_tokens:
-            usage = None
-        else:
-            usage = CompletionUsage(
-                prompt_tokens=int(self.input_tokens or 0),
-                completion_tokens=int(self.output_tokens or 0),
-                total_tokens=int(self.input_tokens or 0) + int(self.output_tokens or 0),
-            )
-        completion = ChatCompletion(
-            id=self.id if self.id else "",
-            model=self.model,
-            choices=[
-                Choice(
-                    finish_reason=self.finish_reasons[0]
-                    if self.finish_reasons and self.finish_reasons[0]
-                    else "stop",
-                    index=0,
-                    message=ChatCompletionMessage.model_validate(message),
-                )
-            ],
-            created=0,
-            object="chat.completion",
-            usage=usage,
-        )
-        return GroqCallResponse(
-            metadata=self.metadata,
-            response=completion,
-            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