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

mirascope/core/litellm/stream.py

@@ -1,86 +0,0 @@
-"""The `LiteLLMStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from collections.abc import AsyncGenerator, Generator
-
-from litellm import Choices, Message
-from litellm.cost_calculator import completion_cost
-from litellm.types.utils import ModelResponse
-
-from ..base.types import CostMetadata
-from ..openai import OpenAIStream, OpenAITool
-from .call_response import LiteLLMCallResponse
-from .call_response_chunk import LiteLLMCallResponseChunk
-
-
-class LiteLLMStream(OpenAIStream):
-    """A simple wrapper around `OpenAIStream`.
-
-    Everything is the same except updates to the `construct_call_response` method and
-    the `cost` property so that cost is properly calculated using LiteLLM's cost
-    calculation method. This ensures cost calculation works for non-OpenAI models.
-    """
-
-    _provider = "litellm"
-
-    def __iter__(
-        self,
-    ) -> Generator[tuple[LiteLLMCallResponseChunk, OpenAITool | None], None, None]:
-        yield from super().__iter__()  # pyright: ignore [reportReturnType]
-
-    def __aiter__(
-        self,
-    ) -> AsyncGenerator[tuple[LiteLLMCallResponseChunk, OpenAITool | None], None]:
-        return super().__aiter__()  # pyright: ignore [reportReturnType] # pragma: no cover
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Returns metadata needed for cost calculation."""
-        response = self.construct_call_response()
-        return CostMetadata(
-            cost=response.cost,
-        )
-
-    def construct_call_response(self) -> LiteLLMCallResponse:
-        openai_call_response = super().construct_call_response()
-        openai_response = openai_call_response.response
-        model_response = ModelResponse(
-            id=openai_response.id,
-            choices=[
-                Choices(
-                    finish_reason=choice.finish_reason,
-                    index=choice.index,
-                    message=Message(**choice.message.model_dump()),
-                    logprobs=choice.logprobs,
-                )
-                for choice in openai_response.choices
-            ],
-            created=openai_response.created,
-            model=openai_response.model,
-            object=openai_response.object,
-            system_fingerprint=openai_response.system_fingerprint,
-            usage=openai_response.usage.model_dump() if openai_response.usage else None,
-        )
-        model_response._hidden_params["response_cost"] = completion_cost(
-            model=self.model,
-            messages=openai_call_response.messages,
-            completion=openai_call_response.content,
-        )
-        response = LiteLLMCallResponse(
-            metadata=openai_call_response.metadata,
-            response=model_response,  # pyright: ignore [reportArgumentType]
-            tool_types=openai_call_response.tool_types,
-            prompt_template=openai_call_response.prompt_template,
-            fn_args=openai_call_response.fn_args,
-            dynamic_config=openai_call_response.dynamic_config,
-            messages=openai_call_response.messages,
-            call_params=openai_call_response.call_params,
-            call_kwargs=openai_call_response.call_kwargs,
-            user_message_param=openai_call_response.user_message_param,
-            start_time=openai_call_response.start_time,
-            end_time=openai_call_response.end_time,
-        )
-        response._model = self.model
-        return response

mirascope/core/litellm/tool.py

@@ -1,13 +0,0 @@
-"""The `LiteLLMTool` class for easy tool usage with LiteLLM LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from ..openai import OpenAITool
-
-
-class LiteLLMTool(OpenAITool):
-    """A simple wrapper around `OpenAITool`.
-
-    Since LiteLLM uses the OpenAI spec, we change nothing here.
-    """

mirascope/core/mistral/__init__.py

@@ -1,36 +0,0 @@
-"""The Mirascope Mistral Module."""
-
-from typing import TypeAlias
-
-from mistralai.models import (
-    AssistantMessage,
-    SystemMessage,
-    ToolMessage,
-    UserMessage,
-)
-
-from ..base import BaseMessageParam
-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
-
-MistralMessageParam: TypeAlias = (
-    AssistantMessage | SystemMessage | ToolMessage | UserMessage | BaseMessageParam
-)
-
-__all__ = [
-    "MistralCallParams",
-    "MistralCallResponse",
-    "MistralCallResponseChunk",
-    "MistralDynamicConfig",
-    "MistralMessageParam",
-    "MistralStream",
-    "MistralTool",
-    "call",
-    "mistral_call",
-]

mirascope/core/mistral/_call.py

@@ -1,65 +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 .stream import MistralStream
-from .tool import MistralTool
-
-mistral_call = call_factory(
-    TCallResponse=MistralCallResponse,
-    TCallResponseChunk=MistralCallResponseChunk,
-    TToolType=MistralTool,
-    TStream=MistralStream,
-    default_call_params=MistralCallParams(),
-    setup_call=setup_call,
-    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 prompt template 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")
-def recommend_book(genre: str) -> str:
-    return f"Recommend a {genre} book"
-
-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/_call_kwargs.py

@@ -1,19 +0,0 @@
-"""This module contains the type definition for the Mistral call keyword arguments."""
-
-from collections.abc import Sequence
-from typing import Any
-
-from mistralai.models import (
-    AssistantMessage,
-    SystemMessage,
-    ToolMessage,
-    UserMessage,
-)
-
-from ..base import BaseCallKwargs
-from .call_params import MistralCallParams
-
-
-class MistralCallKwargs(MistralCallParams, BaseCallKwargs[dict[str, Any]]):
-    model: str
-    messages: Sequence[AssistantMessage | SystemMessage | ToolMessage | UserMessage]

mirascope/core/mistral/_utils/__init__.py

@@ -1,14 +0,0 @@
-"""Mistral utilities for decorator factories."""
-
-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__ = [
-    "convert_message_params",
-    "get_json_output",
-    "handle_stream",
-    "handle_stream_async",
-    "setup_call",
-]

mirascope/core/mistral/_utils/_convert_common_call_params.py

@@ -1,24 +0,0 @@
-from typing import cast
-
-from ...base.call_params import CommonCallParams
-from ..call_params import MistralCallParams
-
-MISTRAL_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "max_tokens",
-    "top_p": "top_p",
-    "seed": "random_seed",
-    "stop": "stop",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> MistralCallParams:
-    """Convert CommonCallParams to Mistral parameters."""
-    return cast(
-        MistralCallParams,
-        {
-            MISTRAL_PARAM_MAPPING[key]: value
-            for key, value in common_params.items()
-            if key in MISTRAL_PARAM_MAPPING and value is not None
-        },
-    )

mirascope/core/mistral/_utils/_convert_finish_reason_to_common_finish_reasons.py

@@ -1,22 +0,0 @@
-from mirascope.core.base._utils._convert_provider_finish_reason_to_finish_reason import (
-    FinishReasonMappingValue,
-    _convert_finish_reasons_to_common_finish_reasons_from_mapping,
-)
-from mirascope.core.base.types import FinishReason
-
-_FinishReasonMapping: dict[str, FinishReasonMappingValue] = {
-    "stop": "stop",
-    "length": "length",
-    "model_length": "length",
-    "error": "stop",
-    "tool_calls": "tool_calls",
-}
-
-
-def _convert_finish_reasons_to_common_finish_reasons(
-    finish_reasons: list[str],
-) -> list[FinishReason] | None:
-    """Provider-agnostic finish reasons."""
-    return _convert_finish_reasons_to_common_finish_reasons_from_mapping(
-        finish_reasons, _FinishReasonMapping
-    )

mirascope/core/mistral/_utils/_convert_message_params.py

@@ -1,122 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ChatMessage`."""
-
-import base64
-
-from mistralai.models import (
-    AssistantMessage,
-    FunctionCall,
-    ImageURL,
-    ImageURLChunk,
-    SystemMessage,
-    TextChunk,
-    ToolCall,
-    ToolMessage,
-    UserMessage,
-)
-
-from ...base import BaseMessageParam
-
-
-def _make_message(
-    role: str,
-    **kwargs,  # noqa: ANN003
-) -> AssistantMessage | SystemMessage | ToolMessage | UserMessage:
-    if role == "assistant":
-        return AssistantMessage(**kwargs)
-    elif role == "system":
-        return SystemMessage(**kwargs)
-    elif role == "tool":
-        return ToolMessage(**kwargs)
-    elif role == "user":
-        return UserMessage(**kwargs)
-    raise ValueError(f"Invalid role: {role}")
-
-
-def convert_message_params(
-    message_params: list[
-        BaseMessageParam | AssistantMessage | SystemMessage | ToolMessage | UserMessage
-    ],
-) -> list[AssistantMessage | SystemMessage | ToolMessage | UserMessage]:
-    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(_make_message(**message_param.model_dump()))
-        else:
-            converted_content = []
-            for part in content:
-                if part.type == "text":
-                    converted_content.append(TextChunk(text=part.text))
-
-                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}. Mistral"
-                            " currently only supports JPEG, PNG, GIF, and WebP images."
-                        )
-                    data = base64.b64encode(part.image).decode("utf-8")
-                    converted_content.append(
-                        ImageURLChunk(
-                            image_url=ImageURL(
-                                url=f"data:{part.media_type};base64,{data}",
-                                detail=part.detail if part.detail else "auto",
-                            )
-                        )
-                    )
-                elif part.type == "image_url":
-                    converted_content.append(
-                        {
-                            "type": "image_url",
-                            "image_url": part.url,
-                        }
-                    )
-                elif part.type == "tool_call":
-                    converted_message_params.append(
-                        AssistantMessage(
-                            role="assistant",
-                            content=converted_content if converted_content else None,
-                            tool_calls=[
-                                ToolCall(
-                                    function=FunctionCall(
-                                        name=part.name,
-                                        arguments=part.args,  # pyright: ignore [reportArgumentType]
-                                    ),
-                                    id=part.id,
-                                    type="function",
-                                ),
-                            ],
-                        )
-                    )
-                    converted_content = []
-                elif part.type == "tool_result":
-                    if converted_content:
-                        converted_message_params.append(
-                            _make_message(
-                                role=message_param.role, content=converted_content
-                            )
-                        )
-                        converted_content = []
-                    converted_message_params.append(
-                        ToolMessage(
-                            role="tool",
-                            content=part.content,
-                            tool_call_id=part.id,
-                            name=part.name,
-                        )
-                    )
-                else:
-                    raise ValueError(
-                        "Mistral currently only supports text and image parts. "
-                        f"Part provided: {part.type}"
-                    )
-            if converted_content:
-                converted_message_params.append(
-                    _make_message(role=message_param.role, content=converted_content)
-                )
-    return converted_message_params

mirascope/core/mistral/_utils/_get_json_output.py

@@ -1,34 +0,0 @@
-"""Get the JSON output from a completion response."""
-
-from typing import cast
-
-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 (
-            (choices := response.response.choices)
-            and choices
-            and (tool_calls := choices[0].message.tool_calls)
-        ):
-            return cast(str, 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 cast(str, arguments)
-        return ""

mirascope/core/mistral/_utils/_handle_stream.py

@@ -1,139 +0,0 @@
-"""Handles the stream of completion chunks."""
-
-from collections.abc import AsyncGenerator, Generator
-from typing import cast
-
-from mistralai.models import (
-    CompletionEvent,
-    FunctionCall,
-    ToolCall,
-)
-
-from ..call_response_chunk import MistralCallResponseChunk
-from ..tool import MistralTool
-
-
-def _handle_chunk(
-    chunk: CompletionEvent,
-    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.data.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="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 += cast(str, tool_call.function.arguments)  # pyright: ignore [reportOperatorIssue]
-
-    return None, current_tool_call, current_tool_type
-
-
-def handle_stream(
-    stream: Generator[CompletionEvent, None, None],
-    tool_types: list[type[MistralTool]] | None,
-    partial_tools: bool = False,
-) -> 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="function"
-    )
-    current_tool_type = None
-    last_chuk_data = None
-    for chunk in stream:
-        if not tool_types or not chunk.data.choices[0].delta.tool_calls:
-            if current_tool_type:
-                yield (
-                    MistralCallResponseChunk(chunk=chunk.data),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield MistralCallResponseChunk(chunk=chunk.data), 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.data), tool
-        else:
-            last_chuk_data = chunk.data
-    if current_tool_type and last_chuk_data:
-        yield (
-            MistralCallResponseChunk(chunk=last_chuk_data),
-            current_tool_type.from_tool_call(current_tool_call),
-        )
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[CompletionEvent, None],
-    tool_types: list[type[MistralTool]] | None,
-    partial_tools: bool = False,
-) -> 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="function"
-    )
-    current_tool_type = None
-    last_chuk_data = None
-    async for chunk in stream:
-        if not tool_types or not chunk.data.choices[0].delta.tool_calls:
-            if current_tool_type:
-                yield (
-                    MistralCallResponseChunk(chunk=chunk.data),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield MistralCallResponseChunk(chunk=chunk.data), 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.data), tool
-        else:
-            last_chuk_data = chunk.data
-    if current_tool_type and last_chuk_data:
-        yield (
-            MistralCallResponseChunk(chunk=last_chuk_data),
-            current_tool_type.from_tool_call(current_tool_call),
-        )