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

mirascope/core/mistral/_utils/_handle_stream.py

@@ -1,121 +0,0 @@
-"""Handles the stream of completion chunks."""
-
-from collections.abc import AsyncGenerator, Generator
-
-from mistralai.models.chat_completion import (
-    ChatCompletionStreamResponse,
-    FunctionCall,
-    ToolCall,
-    ToolType,
-)
-
-from ..call_response_chunk import MistralCallResponseChunk
-from ..tool import MistralTool
-
-
-def _handle_chunk(
-    chunk: ChatCompletionStreamResponse,
-    current_tool_call: ToolCall,
-    current_tool_type: type[MistralTool] | None,
-    tool_types: list[type[MistralTool]] | None,
-) -> tuple[
-    MistralTool | None,
-    ToolCall,
-    type[MistralTool] | 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 != "null" and tool_call.function is not None:
-        previous_tool_call = current_tool_call.model_copy()
-        previous_tool_type = current_tool_type
-        current_tool_call = ToolCall(
-            id=tool_call.id,
-            function=FunctionCall(
-                arguments="",
-                name=tool_call.function.name if tool_call.function.name else "",
-            ),
-            type=ToolType.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_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[ChatCompletionStreamResponse, None, None],
-    tool_types: list[type[MistralTool]] | None,
-) -> Generator[tuple[MistralCallResponseChunk, MistralTool | None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ToolCall(
-        id="", function=FunctionCall(arguments="", name=""), type=ToolType.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 (
-                    MistralCallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield MistralCallResponseChunk(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 MistralCallResponseChunk(chunk=chunk), tool
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[ChatCompletionStreamResponse, None],
-    tool_types: list[type[MistralTool]] | None,
-) -> AsyncGenerator[tuple[MistralCallResponseChunk, MistralTool | None], None]:
-    """Async iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ToolCall(
-        id="", function=FunctionCall(arguments="", name=""), type=ToolType.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 (
-                    MistralCallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield MistralCallResponseChunk(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 MistralCallResponseChunk(chunk=chunk), tool

mirascope/core/mistral/_utils/_setup_call.py

@@ -1,86 +0,0 @@
-"""This module contains the setup_call function for Mistral tools."""
-
-import inspect
-from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine, Iterable
-from typing import Any, cast
-
-from mistralai.async_client import MistralAsyncClient
-from mistralai.client import MistralClient
-from mistralai.models.chat_completion import (
-    ChatCompletionResponse,
-    ChatCompletionStreamResponse,
-    ChatMessage,
-    ResponseFormat,
-    ResponseFormats,
-    ToolChoice,
-)
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ..call_params import MistralCallParams
-from ..dynamic_config import MistralDynamicConfig
-from ..tool import MistralTool
-from ._convert_message_params import convert_message_params
-
-
-def setup_call(
-    *,
-    model: str,
-    client: MistralClient | MistralAsyncClient | None,
-    fn: Callable[..., MistralDynamicConfig | Awaitable[MistralDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: MistralDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: MistralCallParams,
-    extract: bool,
-) -> tuple[
-    Callable[..., ChatCompletionResponse]
-    | Callable[..., Awaitable[ChatCompletionResponse]],
-    str,
-    list[ChatMessage],
-    list[type[MistralTool]] | None,
-    dict[str, Any],
-]:
-    prompt_template, messages, tool_types, call_kwargs = _utils.setup_call(
-        fn, fn_args, dynamic_config, tools, MistralTool, call_params
-    )
-    messages = cast(list[BaseMessageParam | ChatMessage], messages)
-    messages = convert_message_params(messages)
-    if json_mode:
-        call_kwargs["response_format"] = ResponseFormat(
-            type=ResponseFormats("json_object")
-        )
-        json_mode_content = _utils.json_mode_content(
-            tool_types[0] if tool_types else None
-        )
-        if messages[-1].role == "user":
-            messages[-1].content += json_mode_content
-        else:
-            messages.append(ChatMessage(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"] = ToolChoice.any
-    call_kwargs |= {"model": model, "messages": messages}
-
-    if client is None:
-        client = (
-            MistralAsyncClient() if inspect.iscoroutinefunction(fn) else MistralClient()
-        )
-
-    def create_or_stream(
-        stream: bool,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> (
-        Iterable[ChatCompletionStreamResponse]
-        | AsyncGenerator[  # noqa: ANN401
-            ChatCompletionStreamResponse, None
-        ]
-        | ChatCompletionResponse
-        | Coroutine[Any, Any, ChatCompletionResponse]
-    ):
-        if stream:
-            return client.chat_stream(**kwargs)
-        return client.chat(**kwargs)
-
-    return create_or_stream, prompt_template, messages, tool_types, call_kwargs  # type: ignore

mirascope/core/mistral/call_params.py

@@ -1,36 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from mistralai.models.chat_completion import ResponseFormat, ToolChoice
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-
-class MistralCallParams(BaseCallParams):
-    """The parameters to use when calling the Mistral API.
-
-    [Mistral API Reference](https://docs.mistral.ai/api/)
-
-    Attributes:
-        endpoint: ...
-        max_tokens: ...
-        random_seed: ...
-        response_format: ...
-        safe_mode: ...
-        safe_prompt: ...
-        temperature: ...
-        tool_choice: ...
-        top_p: ...
-    """
-
-    endpoint: NotRequired[str | None]
-    max_tokens: NotRequired[int | None]
-    random_seed: NotRequired[int | None]
-    response_format: NotRequired[ResponseFormat | None]
-    safe_mode: NotRequired[bool | None]
-    safe_prompt: NotRequired[bool | None]
-    temperature: NotRequired[float | None]
-    tool_choice: NotRequired[ToolChoice | None]
-    top_p: NotRequired[float | None]

mirascope/core/mistral/call_response.py

@@ -1,156 +0,0 @@
-"""This module contains the `MistralCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from mistralai.models.chat_completion import ChatCompletionResponse, ChatMessage
-from mistralai.models.common import UsageInfo
-from pydantic import computed_field
-
-from ..base import BaseCallResponse
-from ._utils import calculate_cost
-from .call_params import MistralCallParams
-from .dynamic_config import MistralDynamicConfig
-from .tool import MistralTool
-
-
-class MistralCallResponse(
-    BaseCallResponse[
-        ChatCompletionResponse,
-        MistralTool,
-        MistralDynamicConfig,
-        ChatMessage,
-        MistralCallParams,
-        ChatMessage,
-    ]
-):
-    """A convenience wrapper around the Mistral `ChatCompletion` response.
-
-    When calling the Mistral API using a function decorated with `mistral_call`, the
-    response will be an `MistralCallResponse` instance with properties that allow for
-    more convenience access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.mistral import mistral_call
-
-
-    @mistral_call("mistral-largel-latest")
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")  # response is an `MistralCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _provider = "mistral"
-
-    @property
-    def content(self) -> str:
-        """The content of the chat completion for the 0th choice."""
-        return self.response.choices[0].message.content
-
-    @property
-    def finish_reasons(self) -> list[str]:
-        """Returns the finish reasons of the response."""
-        return [
-            choice.finish_reason if choice.finish_reason else ""
-            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) -> UsageInfo:
-        """Returns the usage of the chat completion."""
-        return self.response.usage
-
-    @property
-    def input_tokens(self) -> int:
-        """Returns the number of input tokens."""
-        return self.usage.prompt_tokens
-
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        return self.usage.completion_tokens
-
-    @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) -> ChatMessage:
-        """Returns the assistants's response as a message parameter."""
-        return self.response.choices[0].message
-
-    @computed_field
-    @property
-    def tools(self) -> list[MistralTool] | None:
-        """Returns the tools for the 0th choice message.
-
-        Raises:
-            ValidationError: if the 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) -> MistralTool | 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[MistralTool, str]]
-    ) -> list[ChatMessage]:
-        """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 `ChatMessage` parameters.
-        """
-        return [
-            ChatMessage(
-                role="tool",
-                content=output,
-                tool_call_id=tool.tool_call.id,
-                name=tool._name(),
-            )
-            for tool, output in tools_and_outputs
-        ]

mirascope/core/mistral/call_response_chunk.py

@@ -1,84 +0,0 @@
-"""This module contains the `MistralCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from mistralai.models.chat_completion import ChatCompletionStreamResponse, FinishReason
-from mistralai.models.common import UsageInfo
-
-from ..base import BaseCallResponseChunk
-
-
-class MistralCallResponseChunk(
-    BaseCallResponseChunk[ChatCompletionStreamResponse, FinishReason]
-):
-    """A convenience wrapper around the Mistral `ChatCompletionChunk` streamed chunks.
-
-    When calling the Mistral API using a function decorated with `mistral_call` and
-    `stream` set to `True`, the stream will contain `MistralResponseChunk` instances with
-    properties that allow for more convenient access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.mistral import mistral_call
-
-
-    @mistral_call("mistral-large-latest", stream=True)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # response is an `MistralStream`
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    @property
-    def content(self) -> str:
-        """Returns the content of the delta."""
-        delta = None
-        if self.chunk.choices:
-            delta = self.chunk.choices[0].delta
-        return delta.content if delta is not None and delta.content is not None 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) -> UsageInfo | None:
-        """Returns the usage of the chat completion."""
-        return self.chunk.usage
-
-    @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/mistral/dynamic_config.py

@@ -1,24 +0,0 @@
-"""This module defines the function return type for functions as LLM calls.
-
-usage docs: learn/dynamic_configuration.md#dynamic-configuration-options
-"""
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import MistralCallParams
-
-MistralDynamicConfig = BaseDynamicConfig[BaseMessageParam, MistralCallParams]
-"""The function return type for functions wrapped with the `mistral_call` decorator.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.mistral import MistralDynamicConfig, mistral_call
-
-
-@mistral_call("mistral-large-latest")
-@prompt_template("Recommend a {capitalized_genre} book")
-def recommend_book(genre: str) -> MistralDynamicConfig:
-    return {"computed_fields": {"capitalized_genre": genre.capitalize()}}
-```
-"""

mirascope/core/mistral/stream.py

@@ -1,117 +0,0 @@
-"""The `MistralStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from mistralai.models.chat_completion import (
-    ChatCompletionResponse,
-    ChatCompletionResponseChoice,
-    ChatMessage,
-    FinishReason,
-)
-from mistralai.models.common import UsageInfo
-
-from ..base.stream import BaseStream
-from ._utils import calculate_cost
-from .call_params import MistralCallParams
-from .call_response import MistralCallResponse
-from .call_response_chunk import MistralCallResponseChunk
-from .dynamic_config import MistralDynamicConfig
-from .tool import MistralTool
-
-
-class MistralStream(
-    BaseStream[
-        MistralCallResponse,
-        MistralCallResponseChunk,
-        ChatMessage,
-        ChatMessage,
-        ChatMessage,
-        ChatMessage,
-        MistralTool,
-        MistralDynamicConfig,
-        MistralCallParams,
-        FinishReason,
-    ]
-):
-    """A class for convenience around streaming Mistral LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.mistral import mistral_call
-
-
-    @mistral_call("mistral-large-latest", stream=True)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # returns `MistralStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "mistral"
-
-    @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 | None = None, content: str | None = None
-    ) -> ChatMessage:
-        message_param = ChatMessage(
-            role="assistant", content=content if content else "", tool_calls=tool_calls
-        )
-        return message_param
-
-    def construct_call_response(self) -> MistralCallResponse:
-        """Constructs the call response from a consumed MistralStream.
-
-        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."
-            )
-        usage = UsageInfo(
-            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 = ChatCompletionResponse(
-            id=self.id if self.id else "",
-            choices=[
-                ChatCompletionResponseChoice(
-                    finish_reason=self.finish_reasons[0]
-                    if self.finish_reasons
-                    else None,
-                    index=0,
-                    message=self.message_param,
-                )
-            ],
-            created=0,
-            model=self.model,
-            object="",
-            usage=usage,
-        )
-        return MistralCallResponse(
-            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,
-        )