mirascope 1.25.7__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

mirascope/core/mistral/call_response.py

@@ -1,205 +0,0 @@
-"""This module contains the `MistralCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-from typing import Any, cast
-
-from mistralai import ChatCompletionChoice
-from mistralai.models import (
-    AssistantMessage,
-    ChatCompletionResponse,
-    SystemMessage,
-    ToolMessage,
-    UsageInfo,
-    UserMessage,
-)
-from pydantic import computed_field
-
-from .. import BaseMessageParam
-from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import CostMetadata, FinishReason
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-from ._utils._message_param_converter import MistralMessageParamConverter
-from .call_params import MistralCallParams
-from .dynamic_config import MistralDynamicConfig
-from .tool import MistralTool
-
-
-class MistralCallResponse(
-    BaseCallResponse[
-        ChatCompletionResponse,
-        MistralTool,
-        dict[str, Any],
-        MistralDynamicConfig,
-        AssistantMessage | SystemMessage | ToolMessage | UserMessage,
-        MistralCallParams,
-        UserMessage,
-        MistralMessageParamConverter,
-    ]
-):
-    """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")
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-    response = recommend_book("fantasy")  # response is an `MistralCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _message_converter: type[MistralMessageParamConverter] = (
-        MistralMessageParamConverter
-    )
-
-    _provider = "mistral"
-
-    @property
-    def _response_choices(self) -> list[ChatCompletionChoice]:
-        return self.response.choices or []
-
-    @computed_field
-    @property
-    def content(self) -> str:
-        """The content of the chat completion for the 0th choice."""
-        return cast(str, self._response_choices[0].message.content) or ""
-
-    @computed_field
-    @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
-        ]
-
-    @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) -> UsageInfo:
-        """Returns the usage of the chat completion."""
-        return self.response.usage
-
-    @computed_field
-    @property
-    def input_tokens(self) -> int:
-        """Returns the number of input tokens."""
-        return self.usage.prompt_tokens
-
-    @computed_field
-    @property
-    def cached_tokens(self) -> int:
-        """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
-
-    @computed_field
-    @cached_property
-    def message_param(self) -> AssistantMessage:
-        """Returns the assistants's response as a message parameter."""
-        return self._response_choices[0].message
-
-    @cached_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
-
-    @cached_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
-    @transform_tool_outputs
-    def tool_message_params(
-        cls, tools_and_outputs: Sequence[tuple[MistralTool, str]]
-    ) -> list[ToolMessage]:
-        """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 `ChatMessage` parameters.
-        """
-        return [
-            ToolMessage(
-                content=output,
-                tool_call_id=tool.tool_call.id,  # pyright: ignore [reportOptionalMemberAccess]
-                name=tool._name(),
-            )
-            for tool, output in tools_and_outputs
-        ]
-
-    @property
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
-
-    @property
-    def common_message_param(self) -> BaseMessageParam:
-        return MistralMessageParamConverter.from_provider([self.message_param])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return MistralMessageParamConverter.from_provider([self.user_message_param])[0]
-
-    @computed_field
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Get metadata required for cost calculation."""
-        return super().cost_metadata

mirascope/core/mistral/call_response_chunk.py

@@ -1,105 +0,0 @@
-"""This module contains the `MistralCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from typing import cast
-
-from mistralai.models import CompletionChunk, FinishReason, UsageInfo
-
-from ..base import BaseCallResponseChunk, types
-from ..base.types import CostMetadata
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-
-
-class MistralCallResponseChunk(BaseCallResponseChunk[CompletionChunk, 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)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    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
-
-        if delta is not None and isinstance(delta.content, str):
-            return delta.content
-        return ""
-
-    @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 cached_tokens(self) -> int:
-        """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[types.FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(
-            cast(list[str], self.finish_reasons)
-        )

mirascope/core/mistral/dynamic_config.py

@@ -1,33 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from mistralai import Mistral
-from mistralai.models import (
-    AssistantMessage,
-    SystemMessage,
-    ToolMessage,
-    UserMessage,
-)
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import MistralCallParams
-
-MistralDynamicConfig = BaseDynamicConfig[
-    AssistantMessage | SystemMessage | ToolMessage | UserMessage | BaseMessageParam,
-    MistralCallParams,
-    Mistral,
-]
-"""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,120 +0,0 @@
-"""The `MistralStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from typing import Any, cast
-
-from mistralai.models import (
-    AssistantMessage,
-    ChatCompletionChoice,
-    ChatCompletionResponse,
-    FinishReason,
-    SystemMessage,
-    ToolMessage,
-    UsageInfo,
-    UserMessage,
-)
-
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-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,
-        UserMessage,
-        AssistantMessage,
-        ToolMessage,
-        AssistantMessage | SystemMessage | ToolMessage | UserMessage,
-        MistralTool,
-        dict[str, Any],
-        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)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    stream = recommend_book("fantasy")  # returns `MistralStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "mistral"
-
-    def _construct_message_param(
-        self, tool_calls: list | None = None, content: str | None = None
-    ) -> AssistantMessage:
-        message_param = AssistantMessage(
-            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),
-        )
-        finish_reason = cast(FinishReason, (self.finish_reasons or [])[0])
-        completion = ChatCompletionResponse(
-            id=self.id if self.id else "",
-            choices=[
-                ChatCompletionChoice(
-                    finish_reason=finish_reason,
-                    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,
-        )
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        return super().cost_metadata

mirascope/core/mistral/tool.py

@@ -1,81 +0,0 @@
-"""The `MistralTool` class for easy tool usage with Mistral LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-import jiter
-from mistralai.models 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])
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns a `MistralTool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "mistral"
-
-    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_json_schema()
-        fn["parameters"] = (
-            model_schema if model_schema["properties"] else {"type": "object"}
-        )
-        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 = {"tool_call": tool_call}
-        if args := tool_call.function.arguments:
-            model_json |= (
-                jiter.from_json(args.encode()) if isinstance(args, str) else args
-            )
-        return cls.model_validate(model_json)

mirascope/core/openai/__init__.py

@@ -1,31 +0,0 @@
-"""The Mirascope OpenAI Module."""
-
-from typing import TypeAlias
-
-from openai.types.chat import ChatCompletionMessageParam
-
-from ..base import BaseMessageParam
-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 AsyncOpenAIDynamicConfig, OpenAIDynamicConfig
-from .stream import OpenAIStream
-from .tool import OpenAITool, OpenAIToolConfig
-
-OpenAIMessageParam: TypeAlias = ChatCompletionMessageParam | BaseMessageParam
-
-__all__ = [
-    "AsyncOpenAIDynamicConfig",
-    "OpenAICallParams",
-    "OpenAICallResponse",
-    "OpenAICallResponseChunk",
-    "OpenAIDynamicConfig",
-    "OpenAIMessageParam",
-    "OpenAIStream",
-    "OpenAITool",
-    "OpenAIToolConfig",
-    "call",
-    "openai_call",
-]

mirascope/core/openai/_call.py

@@ -1,67 +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 .stream import OpenAIStream
-from .tool import OpenAITool
-
-openai_call = call_factory(
-    TCallResponse=OpenAICallResponse,
-    TCallResponseChunk=OpenAICallResponseChunk,
-    TToolType=OpenAITool,
-    TStream=OpenAIStream,
-    default_call_params=OpenAICallParams(),
-    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 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 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.openai import openai_call
-
-
-@openai_call("gpt-4o-mini")
-def recommend_book(genre: str) -> str:
-    return f"Recommend a {genre} book"
-
-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/_call_kwargs.py

@@ -1,13 +0,0 @@
-"""This module contains the type definition for the OpenAI call keyword arguments."""
-
-from collections.abc import Sequence
-
-from openai.types.chat import ChatCompletionMessageParam, ChatCompletionToolParam
-
-from ..base import BaseCallKwargs
-from .call_params import OpenAICallParams
-
-
-class OpenAICallKwargs(OpenAICallParams, BaseCallKwargs[ChatCompletionToolParam]):
-    model: str
-    messages: Sequence[ChatCompletionMessageParam]

mirascope/core/openai/_utils/__init__.py

@@ -1,14 +0,0 @@
-"""OpenAI 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",
-]