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

mirascope/core/mistral/tool.py

@@ -1,77 +0,0 @@
-"""The `MistralTool` class for easy tool usage with Mistral LLM calls.
-
-usage docs: learn/tools.md#using-tools-with-standard-calls
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-import jiter
-from mistralai.models.chat_completion import ToolCall
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool
-
-
-class MistralTool(BaseTool):
-    """A class for defining tools for Mistral LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.mistral import mistral_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @mistral_call("mistral-large-latest", tools=[format_book])
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns a `MistralTool` instance
-        print(tool.call())
-    ```
-    """
-
-    tool_call: SkipJsonSchema[ToolCall]
-
-    @classmethod
-    def tool_schema(cls) -> dict[str, Any]:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.mistral import MistralTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = MistralTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Mistral-specific tool schema
-        ```
-        """
-        fn: dict[str, Any] = {"name": cls._name(), "description": cls._description()}
-        model_schema = cls.model_tool_schema()
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema
-        return {"function": fn, "type": "function"}
-
-    @classmethod
-    def from_tool_call(cls, tool_call: ToolCall) -> MistralTool:
-        """Constructs an `MistralTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Mistral 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/openai/__init__.py

@@ -1,21 +0,0 @@
-"""The Mirascope OpenAI Module."""
-
-from ._call import openai_call
-from ._call import openai_call as call
-from .call_params import OpenAICallParams
-from .call_response import OpenAICallResponse
-from .call_response_chunk import OpenAICallResponseChunk
-from .dynamic_config import OpenAIDynamicConfig
-from .stream import OpenAIStream
-from .tool import OpenAITool
-
-__all__ = [
-    "call",
-    "OpenAIDynamicConfig",
-    "OpenAICallParams",
-    "OpenAICallResponse",
-    "OpenAICallResponseChunk",
-    "OpenAIStream",
-    "OpenAITool",
-    "openai_call",
-]

mirascope/core/openai/_call.py

@@ -1,71 +0,0 @@
-"""The `openai_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 OpenAICallParams
-from .call_response import OpenAICallResponse
-from .call_response_chunk import OpenAICallResponseChunk
-from .dynamic_config import OpenAIDynamicConfig
-from .stream import OpenAIStream
-from .tool import OpenAITool
-
-openai_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,
-    handle_stream=handle_stream,
-    handle_stream_async=handle_stream_async,
-)
-"""A decorator for calling the OpenAI API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the OpenAI 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.openai import openai_call
-
-
-@openai_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 OpenAI 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 OpenAI 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 (object): An optional custom client to use in place of the default 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 an OpenAI API
-        call.
-"""

mirascope/core/openai/_utils/__init__.py

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

@@ -1,110 +0,0 @@
-"""Calculate the cost of a completion using the OpenAI API."""
-
-
-def calculate_cost(
-    input_tokens: int | float | None,
-    output_tokens: int | float | None,
-    model: str = "gpt-3.5-turbo-16k",
-) -> float | None:
-    """Calculate the cost of a completion using the OpenAI API.
-
-    https://openai.com/pricing
-
-    Model                   Input               Output
-    gpt-4o-mini             $0.15 / 1M tokens   $0.60  / 1M tokens
-    gpt-4o-mini-2024-07-18  $0.15 / 1M tokens   $0.60  / 1M tokens
-    gpt-4o                  $5.00 / 1M tokens   $15.00 / 1M tokens
-    gpt-4o-2024-05-13       $5.00 / 1M tokens   $15.00 / 1M tokens
-    gpt-4-turbo             $10.00 / 1M tokens  $30.00 / 1M tokens
-    gpt-4-turbo-2024-04-09  $10.00 / 1M tokens  $30.00 / 1M tokens
-    gpt-3.5-turbo-0125	    $0.50 / 1M tokens	$1.50 / 1M tokens
-    gpt-3.5-turbo-1106	    $1.00 / 1M tokens	$2.00 / 1M tokens
-    gpt-4-1106-preview	    $10.00 / 1M tokens 	$30.00 / 1M tokens
-    gpt-4	                $30.00 / 1M tokens	$60.00 / 1M tokens
-    text-embedding-3-small	$0.02 / 1M tokens
-    text-embedding-3-large	$0.13 / 1M tokens
-    text-embedding-ada-0002	$0.10 / 1M tokens
-    """
-    pricing = {
-        "gpt-4o-mini": {
-            "prompt": 0.000_000_15,
-            "completion": 0.000_000_6,
-        },
-        "gpt-4o-mini-2024-07-18": {
-            "prompt": 0.000_000_15,
-            "completion": 0.000_000_6,
-        },
-        "gpt-4o": {
-            "prompt": 0.000_005,
-            "completion": 0.000_015,
-        },
-        "gpt-4o-2024-05-13": {
-            "prompt": 0.000_005,
-            "completion": 0.000_015,
-        },
-        "gpt-4-turbo": {
-            "prompt": 0.000_01,
-            "completion": 0.000_03,
-        },
-        "gpt-4-turbo-2024-04-09": {
-            "prompt": 0.000_01,
-            "completion": 0.000_03,
-        },
-        "gpt-3.5-turbo-0125": {
-            "prompt": 0.000_000_5,
-            "completion": 0.000_001_5,
-        },
-        "gpt-3.5-turbo-1106": {
-            "prompt": 0.000_001,
-            "completion": 0.000_002,
-        },
-        "gpt-4-1106-preview": {
-            "prompt": 0.000_01,
-            "completion": 0.000_03,
-        },
-        "gpt-4": {
-            "prompt": 0.000_003,
-            "completion": 0.000_006,
-        },
-        "gpt-3.5-turbo-4k": {
-            "prompt": 0.000_015,
-            "completion": 0.000_02,
-        },
-        "gpt-3.5-turbo-16k": {
-            "prompt": 0.000_003,
-            "completion": 0.000_004,
-        },
-        "gpt-4-8k": {
-            "prompt": 0.000_003,
-            "completion": 0.000_006,
-        },
-        "gpt-4-32k": {
-            "prompt": 0.000_006,
-            "completion": 0.000_012,
-        },
-        "text-embedding-3-small": {
-            "prompt": 0.000_000_02,
-            "completion": 0.000_000_02,
-        },
-        "text-embedding-ada-002": {
-            "prompt": 0.000_000_1,
-            "completion": 0.000_000_1,
-        },
-        "text-embedding-3-large": {
-            "prompt": 0.000_000_13,
-            "completion": 0.000_000_13,
-        },
-    }
-    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/openai/_utils/_convert_message_params.py

@@ -1,53 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ChatCompletionMessageParam`."""
-
-import base64
-
-from openai.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}. OpenAI"
-                            " 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",
-                            },
-                        }
-                    )
-                else:
-                    raise ValueError(
-                        "OpenAI currently only supports text and image modalities. "
-                        f"Modality provided: {part.type}"
-                    )
-            converted_message_params.append(
-                {"role": message_param.role, "content": converted_content}
-            )
-    return converted_message_params

mirascope/core/openai/_utils/_get_json_output.py

@@ -1,27 +0,0 @@
-"""Get the JSON output from a completion response."""
-
-from ..call_response import OpenAICallResponse
-from ..call_response_chunk import OpenAICallResponseChunk
-
-
-def get_json_output(
-    response: OpenAICallResponse | OpenAICallResponseChunk, json_mode: bool
-) -> str:
-    """Get the JSON output from a completion response."""
-    if isinstance(response, OpenAICallResponse):
-        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/openai/_utils/_handle_stream.py

@@ -1,125 +0,0 @@
-"""Handles the stream of completion chunks."""
-
-from collections.abc import AsyncGenerator, Generator
-
-from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageToolCall
-from openai.types.chat.chat_completion_message_tool_call import Function
-
-from ..call_response_chunk import OpenAICallResponseChunk
-from ..tool import OpenAITool
-
-
-def _handle_chunk(
-    chunk: ChatCompletionChunk,
-    current_tool_call: ChatCompletionMessageToolCall,
-    current_tool_type: type[OpenAITool] | None,
-    tool_types: list[type[OpenAITool]] | None,
-) -> tuple[
-    OpenAITool | None,
-    ChatCompletionMessageToolCall,
-    type[OpenAITool] | None,
-]:
-    """Handles a chunk of the stream."""
-    if (
-        not tool_types
-        or not chunk.choices
-        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[OpenAITool]] | None,
-) -> Generator[tuple[OpenAICallResponseChunk, OpenAITool | 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 or not chunk.choices[0].delta.tool_calls:
-            if current_tool_type:
-                yield (
-                    OpenAICallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield OpenAICallResponseChunk(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 OpenAICallResponseChunk(chunk=chunk), tool
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[ChatCompletionChunk, None],
-    tool_types: list[type[OpenAITool]] | None,
-) -> AsyncGenerator[tuple[OpenAICallResponseChunk, OpenAITool | 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 (
-                    OpenAICallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield OpenAICallResponseChunk(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 OpenAICallResponseChunk(chunk=chunk), tool

mirascope/core/openai/_utils/_setup_call.py

@@ -1,62 +0,0 @@
-"""This module contains the setup_call function for OpenAI tools."""
-
-import inspect
-from collections.abc import Awaitable, Callable
-from typing import Any, cast
-
-from openai import AsyncAzureOpenAI, AsyncOpenAI, AzureOpenAI, OpenAI
-from openai.types.chat import (
-    ChatCompletion,
-    ChatCompletionMessageParam,
-    ChatCompletionUserMessageParam,
-)
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ..call_params import OpenAICallParams
-from ..dynamic_config import OpenAIDynamicConfig
-from ..tool import OpenAITool
-from ._convert_message_params import convert_message_params
-
-
-def setup_call(
-    *,
-    model: str,
-    client: OpenAI | AsyncOpenAI | AzureOpenAI | AsyncAzureOpenAI | 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 = _utils.setup_call(
-        fn, fn_args, dynamic_config, tools, OpenAITool, 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
-        ).strip()
-        messages.append(
-            ChatCompletionUserMessageParam(role="user", content=json_mode_content)
-        )
-        call_kwargs.pop("tools", None)
-    elif extract:
-        assert tool_types, "At least one tool must be provided for extraction."
-        call_kwargs["tool_choice"] = "required"
-    call_kwargs |= {"model": model, "messages": messages}
-
-    if client is None:
-        client = AsyncOpenAI() if inspect.iscoroutinefunction(fn) else OpenAI()
-    create = client.chat.completions.create
-
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/openai/call_params.py

@@ -1,54 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from openai.types.chat import (
-    ChatCompletionStreamOptionsParam,
-    ChatCompletionToolChoiceOptionParam,
-)
-from openai.types.chat.completion_create_params import ResponseFormat
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-
-class OpenAICallParams(BaseCallParams):
-    """The parameters to use when calling the OpenAI API.
-
-    [OpenAI API Reference](https://platform.openai.com/docs/api-reference/chat/create)
-
-    Attributes:
-        frequency_penalty: ...
-        logit_bias: ...
-        logprobs: ...
-        max_tokens: ...
-        n: ...
-        parallel_tool_calls: ...
-        presence_penalty: ...
-        response_format: ...
-        seed: ...
-        stop: ...
-        stream_options: ...
-        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]
-    stream_options: NotRequired[ChatCompletionStreamOptionsParam | None]
-    temperature: NotRequired[float | None]
-    tool_choice: NotRequired[ChatCompletionToolChoiceOptionParam]
-    top_logprobs: NotRequired[int | None]
-    top_p: NotRequired[float | None]
-    user: NotRequired[str]