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

mirascope/core/groq/call_response_chunk.py

@@ -1,89 +0,0 @@
-"""This module contains the `GroqCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-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
-
-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)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    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 output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        if self.usage:
-            return self.usage.completion_tokens
-        return None

mirascope/core/groq/dynamic_config.py

@@ -1,26 +0,0 @@
-"""This module defines the function return type for functions as LLM calls.
-
-usage docs: learn/dynamic_configuration.md#dynamic-configuration-options
-"""
-
-from groq.types.chat import ChatCompletionMessageParam
-
-from ..base import BaseDynamicConfig
-from .call_params import GroqCallParams
-
-GroqDynamicConfig = BaseDynamicConfig[ChatCompletionMessageParam, GroqCallParams]
-"""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,136 +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,
-    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 ._utils import calculate_cost
-from .call_params import GroqCallParams
-from .call_response import GroqCallResponse
-from .call_response_chunk import GroqCallResponseChunk
-from .dynamic_config import GroqDynamicConfig
-from .tool import GroqTool
-
-FinishReason = Choice.__annotations__["finish_reason"]
-
-
-class GroqStream(
-    BaseStream[
-        GroqCallResponse,
-        GroqCallResponseChunk,
-        ChatCompletionUserMessageParam,
-        ChatCompletionAssistantMessageParam,
-        ChatCompletionToolMessageParam,
-        ChatCompletionMessageParam,
-        GroqTool,
-        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)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # returns `GroqStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "groq"
-
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(self.input_tokens, self.output_tokens, self.model)
-
-    def _construct_message_param(
-        self,
-        tool_calls: list[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,
-        )

mirascope/core/groq/tool.py

@@ -1,79 +0,0 @@
-"""The `GroqTool` class for easy tool usage with Groq LLM calls.
-
-usage docs: learn/tools.md#using-tools-with-standard-calls
-"""
-
-from __future__ import annotations
-
-import jiter
-from groq.types.chat import (
-    ChatCompletionMessageToolCall,
-    ChatCompletionToolParam,
-)
-from groq.types.shared_params import FunctionDefinition
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool
-
-
-class GroqTool(BaseTool):
-    """A class for defining tools for Groq LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.groq import groq_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @groq_call("llama-3.1-8b-instant", tools=[format_book])
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `GroqTool` instance
-        print(tool.call())
-    ```
-    """
-
-    tool_call: SkipJsonSchema[ChatCompletionMessageToolCall]
-
-    @classmethod
-    def tool_schema(cls) -> ChatCompletionToolParam:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.groq import GroqTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = GroqTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Groq-specific tool schema
-        ```
-        """
-        fn = FunctionDefinition(name=cls._name(), description=cls._description())
-        model_schema = cls.model_tool_schema()
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema
-        return ChatCompletionToolParam(function=fn, type="function")
-
-    @classmethod
-    def from_tool_call(cls, tool_call: ChatCompletionMessageToolCall) -> GroqTool:
-        """Constructs an `GroqTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Groq tool call from which to construct this tool instance.
-        """
-        model_json = jiter.from_json(tool_call.function.arguments.encode())
-        model_json["tool_call"] = tool_call.model_dump()
-        return cls.model_validate(model_json)

mirascope/core/litellm/__init__.py

@@ -1,6 +0,0 @@
-"""The Mirascope LiteLLM Module."""
-
-from ._call import litellm_call
-from ._call import litellm_call as call
-
-__all__ = ["call", "litellm_call"]

mirascope/core/litellm/_call.py

@@ -1,73 +0,0 @@
-"""The `litellm_call` decorator for functions as LLM calls."""
-
-from ..base import call_factory
-from ..openai import (
-    OpenAICallParams,
-    OpenAICallResponse,
-    OpenAICallResponseChunk,
-    OpenAIDynamicConfig,
-    OpenAIStream,
-    OpenAITool,
-)
-from ..openai._utils import (
-    get_json_output,
-    handle_stream,
-    handle_stream_async,
-)
-from ._utils import setup_call
-
-litellm_call = call_factory(
-    TCallResponse=OpenAICallResponse,
-    TCallResponseChunk=OpenAICallResponseChunk,
-    TDynamicConfig=OpenAIDynamicConfig,
-    TToolType=OpenAITool,
-    TStream=OpenAIStream,
-    TCallParams=OpenAICallParams,
-    default_call_params=OpenAICallParams(),
-    setup_call=setup_call,  # type: ignore
-    get_json_output=get_json_output,  # type: ignore
-    handle_stream=handle_stream,
-    handle_stream_async=handle_stream_async,
-)
-"""A decorator for calling the LiteLLM API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the LiteLLM 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.litellm import litellm_call
-
-
-@litellm_call("gpt-4o-mini")
-@prompt_template("Recommend a {genre} book")
-def recommend_book(genre: str):
-    ...
-
-response = recommend_book("fantasy")
-print(response.content)
-```
-
-Args:
-    model (str): The 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 API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[OpenAICallResponse | 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 (None): LiteLLM does not support a custom client.
-    call_params (OpenAICallParams): The `OpenAICallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a LiteLLM
-        routed LLM API call.
-"""

mirascope/core/litellm/_utils/__init__.py

@@ -1,5 +0,0 @@
-"""LiteLLM utilities for decorator factories."""
-
-from ._setup_call import setup_call
-
-__all__ = ["setup_call"]

mirascope/core/litellm/_utils/_setup_call.py

@@ -1,46 +0,0 @@
-"""This module contains the setup_call function for OpenAI tools."""
-
-import inspect
-from collections.abc import Awaitable, Callable
-from typing import Any
-
-from litellm import acompletion, completion
-from openai import OpenAI
-from openai.types.chat import ChatCompletion, ChatCompletionMessageParam
-
-from ...base import BaseTool
-from ...openai import OpenAICallParams, OpenAIDynamicConfig, OpenAITool
-from ...openai._utils import setup_call as setup_call_openai
-
-
-def setup_call(
-    *,
-    model: str,
-    client: None,
-    fn: Callable[..., OpenAIDynamicConfig | Awaitable[OpenAIDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: OpenAIDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: OpenAICallParams,
-    extract: bool,
-) -> tuple[
-    Callable[..., ChatCompletion] | Callable[..., Awaitable[ChatCompletion]],
-    str,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    dict[str, Any],
-]:
-    _, prompt_template, messages, tool_types, call_kwargs = setup_call_openai(
-        model=model,
-        client=OpenAI(api_key="NOT_USED"),
-        fn=fn,
-        fn_args=fn_args,
-        dynamic_config=dynamic_config,
-        tools=tools,
-        json_mode=json_mode,
-        call_params=call_params,
-        extract=extract,
-    )
-    create = acompletion if inspect.iscoroutinefunction(fn) else completion
-    return create, prompt_template, messages, tool_types, call_kwargs  # type: ignore

mirascope/core/mistral/__init__.py

@@ -1,21 +0,0 @@
-"""The Mirascope Mistral Module."""
-
-from ._call import mistral_call
-from ._call import mistral_call as call
-from .call_params import MistralCallParams
-from .call_response import MistralCallResponse
-from .call_response_chunk import MistralCallResponseChunk
-from .dynamic_config import MistralDynamicConfig
-from .stream import MistralStream
-from .tool import MistralTool
-
-__all__ = [
-    "call",
-    "MistralDynamicConfig",
-    "MistralCallParams",
-    "MistralCallResponse",
-    "MistralCallResponseChunk",
-    "MistralStream",
-    "MistralTool",
-    "mistral_call",
-]

mirascope/core/mistral/_call.py

@@ -1,69 +0,0 @@
-"""The `mistral_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 MistralCallParams
-from .call_response import MistralCallResponse
-from .call_response_chunk import MistralCallResponseChunk
-from .dynamic_config import MistralDynamicConfig
-from .stream import MistralStream
-from .tool import MistralTool
-
-mistral_call = call_factory(
-    TCallResponse=MistralCallResponse,
-    TCallResponseChunk=MistralCallResponseChunk,
-    TDynamicConfig=MistralDynamicConfig,
-    TToolType=MistralTool,
-    TStream=MistralStream,
-    TCallParams=MistralCallParams,
-    default_call_params=MistralCallParams(),
-    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 Mistral API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Mistral 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.mistral import mistral_call
-
-
-@mistral_call("mistral-large-latest")
-@prompt_template("Recommend a {genre} book")
-def recommend_book(genre: str):
-    ...
-
-response = recommend_book("fantasy")
-print(response.content)
-```
-
-Args:
-    model (str): The Mistral 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 Mistral API call.
-    response_model (BaseModel | BaseType): The response model into which the response should be structured.
-    output_parser (Callable[[MistralCallResponse | 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 (MistralCallParams): The `MistralCallParams` call parameters to use in
-        the API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a Mistral API
-        call.
-"""

mirascope/core/mistral/_utils/__init__.py

@@ -1,16 +0,0 @@
-"""Mistral 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/mistral/_utils/_calculate_cost.py

@@ -1,47 +0,0 @@
-"""Calculate the cost of a completion using the Mistral API."""
-
-
-def calculate_cost(
-    input_tokens: int | float | None,
-    output_tokens: int | float | None,
-    model: str = "open-mistral-7b",
-) -> float | None:
-    """Calculate the cost of a completion using the Mistral API.
-
-    https://mistral.ai/technology/#pricing
-
-    Model                     Input               Output
-    open-mistral-nemo         $0.3/1M tokens	  $0.3/1M tokens
-    mistral-large-latest      $3/1M tokens	      $9/1M tokens
-    codestral-2405            $1/1M tokens	      $3/1M tokens
-    open-mistral-7b	          $0.25/1M tokens	  $0.25/1M tokens
-    open-mixtral-8x7b	      $0.7/1M tokens	  $0.7/1M tokens
-    open-mixtral-8x22b	      $2/1M tokens	      $6/1M tokens
-    mistral-small-latest	  $2/1M tokens	      $6/1M tokens
-    mistral-medium-latest     $2.75/1M tokens	  $8.1/1M tokens
-    """
-    pricing = {
-        "open-mistral-nemo": {"prompt": 0.000_000_3, "completion": 0.000_000_3},
-        "open-mistral-nemo-2407": {"prompt": 0.000_000_3, "completion": 0.000_000_3},
-        "mistral-large-latest": {"prompt": 0.000_003, "completion": 0.000_009},
-        "mistral-large-2407": {"prompt": 0.000_003, "completion": 0.000_009},
-        "open-mistral-7b": {"prompt": 0.000_000_25, "completion": 0.000_000_25},
-        "open-mixtral-8x7b": {"prompt": 0.000_000_7, "completion": 0.000_000_7},
-        "open-mixtral-8x22b": {"prompt": 0.000_002, "completion": 0.000_006},
-        "mistral-small-latest": {"prompt": 0.000_002, "completion": 0.000_006},
-        "mistral-medium-latest": {"prompt": 0.000_002_75, "completion": 0.000_008_1},
-    }
-
-    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/mistral/_utils/_convert_message_params.py

@@ -1,23 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ChatMessage`."""
-
-from mistralai.models.chat_completion import ChatMessage
-
-from ...base import BaseMessageParam
-
-
-def convert_message_params(
-    message_params: list[BaseMessageParam | ChatMessage],
-) -> list[ChatMessage]:
-    converted_message_params = []
-    for message_param in message_params:
-        if isinstance(message_param, ChatMessage):
-            converted_message_params.append(message_param)
-        elif isinstance(content := message_param.content, str):
-            converted_message_params.append(ChatMessage(**message_param.model_dump()))
-        else:
-            if len(content) != 1 or content[0].type != "text":
-                raise ValueError("Mistral does not currently support multimodalities.")
-            converted_message_params.append(
-                ChatMessage(role=message_param.role, content=content[0].text)
-            )
-    return converted_message_params

mirascope/core/mistral/_utils/_get_json_output.py

@@ -1,28 +0,0 @@
-"""Get the JSON output from a completion response."""
-
-from ..call_response import MistralCallResponse
-from ..call_response_chunk import MistralCallResponseChunk
-
-
-def get_json_output(
-    response: MistralCallResponse | MistralCallResponseChunk, json_mode: bool
-) -> str:
-    """Get the JSON output from a completion response."""
-    if isinstance(response, MistralCallResponse):
-        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:
-        # raise ValueError("Mistral does not support structured streaming... :(")
-        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 ""