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

mirascope/llm/_protocols.py

@@ -1,500 +0,0 @@
-"""Protocols for reusable type hints."""
-
-from collections.abc import (
-    AsyncIterable,
-    Callable,
-    Iterable,
-)
-from enum import Enum
-from typing import (
-    Any,
-    Literal,
-    NoReturn,
-    ParamSpec,
-    Protocol,
-    TypeAlias,
-    TypeVar,
-    overload,
-)
-
-from pydantic import BaseModel
-
-from ..core import BaseDynamicConfig, BaseTool
-from ..core.base import (
-    BaseCallResponse,
-    BaseCallResponseChunk,
-    BaseType,
-    CommonCallParams,
-)
-from ..core.base._utils._protocols import (
-    AsyncLLMFunctionDecorator,
-    LLMFunctionDecorator,
-    SyncLLMFunctionDecorator,
-)
-from ..core.base.stream_config import StreamConfig
-from ..core.base.types import LocalProvider, Provider
-from .call_response import CallResponse
-from .call_response_chunk import CallResponseChunk
-from .stream import Stream
-
-_P = ParamSpec("_P")
-_R = TypeVar("_R", contravariant=True)
-
-_BaseStreamT = TypeVar("_BaseStreamT", covariant=True)
-_ResponseModelT = TypeVar("_ResponseModelT", bound=BaseModel | BaseType | Enum)
-_SameSyncAndAsyncClientT = TypeVar("_SameSyncAndAsyncClientT", contravariant=True)
-_SyncBaseClientT = TypeVar("_SyncBaseClientT", contravariant=True)
-_AsyncBaseClientT = TypeVar("_AsyncBaseClientT", contravariant=True)
-_BaseCallParamsT = TypeVar("_BaseCallParamsT", contravariant=True)
-_AsyncBaseDynamicConfigT = TypeVar("_AsyncBaseDynamicConfigT", contravariant=True)
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", contravariant=True)
-_ParsedOutputT = TypeVar("_ParsedOutputT")
-_BaseCallResponseT = TypeVar(
-    "_BaseCallResponseT", bound=BaseCallResponse, covariant=True
-)
-_BaseCallResponseChunkT = TypeVar(
-    "_BaseCallResponseChunkT", bound=BaseCallResponseChunk, covariant=True
-)
-
-
-class _CallDecorator(
-    Protocol[
-        _BaseCallResponseT,
-        _BaseCallResponseChunkT,
-        _BaseDynamicConfigT,
-        _AsyncBaseDynamicConfigT,
-        _BaseCallParamsT,
-        _BaseStreamT,
-        _SyncBaseClientT,
-        _AsyncBaseClientT,
-        _SameSyncAndAsyncClientT,
-    ],
-):
-    @overload
-    def __call__(  # pyright: ignore[reportOverlappingOverload]
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> LLMFunctionDecorator[
-        _BaseDynamicConfigT,
-        _AsyncBaseDynamicConfigT,
-        _BaseCallResponseT,
-        _BaseCallResponseT,
-    ]: ...
-
-    @overload
-    def __call__(  # pyright: ignore[reportOverlappingOverload]
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _AsyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> AsyncLLMFunctionDecorator[_AsyncBaseDynamicConfigT, _BaseCallResponseT]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _SyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> SyncLLMFunctionDecorator[_BaseDynamicConfigT, _BaseCallResponseT]: ...
-
-    @overload
-    def __call__(  # pyright: ignore[reportOverlappingOverload]
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[_BaseCallResponseT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> LLMFunctionDecorator[
-        _BaseDynamicConfigT, _AsyncBaseDynamicConfigT, _ParsedOutputT, _ParsedOutputT
-    ]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[_BaseCallResponseT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _AsyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> AsyncLLMFunctionDecorator[_AsyncBaseDynamicConfigT, _ParsedOutputT]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[_BaseCallResponseT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _SyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> SyncLLMFunctionDecorator[_BaseDynamicConfigT, _ParsedOutputT]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[_BaseCallResponseChunkT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT
-        | _SyncBaseClientT
-        | _AsyncBaseClientT
-        | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> NoReturn: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[True] | StreamConfig = True,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> LLMFunctionDecorator[
-        _BaseDynamicConfigT, _AsyncBaseDynamicConfigT, _BaseStreamT, _BaseStreamT
-    ]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[True] | StreamConfig = True,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _AsyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> AsyncLLMFunctionDecorator[_AsyncBaseDynamicConfigT, _BaseStreamT]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[True] | StreamConfig = True,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _SyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> SyncLLMFunctionDecorator[_BaseDynamicConfigT, _BaseStreamT]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[True] | StreamConfig = True,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[_BaseCallResponseChunkT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT
-        | _SyncBaseClientT
-        | _AsyncBaseClientT
-        | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> NoReturn: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[True] | StreamConfig = True,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: None = None,
-        output_parser: Callable[[_BaseCallResponseT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT
-        | _SyncBaseClientT
-        | _AsyncBaseClientT
-        | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> NoReturn: ...
-
-    @overload
-    def __call__(  # pyright: ignore[reportOverlappingOverload]
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> LLMFunctionDecorator[
-        _BaseDynamicConfigT, _AsyncBaseDynamicConfigT, _ResponseModelT, _ResponseModelT
-    ]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _AsyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> AsyncLLMFunctionDecorator[_AsyncBaseDynamicConfigT, _ResponseModelT]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _SyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> SyncLLMFunctionDecorator[_BaseDynamicConfigT, _ResponseModelT]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> LLMFunctionDecorator[
-        _BaseDynamicConfigT, _AsyncBaseDynamicConfigT, _ParsedOutputT, _ParsedOutputT
-    ]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _AsyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> AsyncLLMFunctionDecorator[_AsyncBaseDynamicConfigT, _ParsedOutputT]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[False] = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_ResponseModelT], _ParsedOutputT],
-        json_mode: bool = False,
-        client: _SyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> SyncLLMFunctionDecorator[_BaseDynamicConfigT, _ParsedOutputT]: ...
-
-    @overload
-    def __call__(  # pyright: ignore[reportOverlappingOverload]
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[True] | StreamConfig,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> LLMFunctionDecorator[
-        _BaseDynamicConfigT,
-        _AsyncBaseDynamicConfigT,
-        Iterable[_ResponseModelT],
-        AsyncIterable[_ResponseModelT],
-    ]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[True] | StreamConfig,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _AsyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> AsyncLLMFunctionDecorator[
-        _AsyncBaseDynamicConfigT, AsyncIterable[_ResponseModelT]
-    ]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[True] | StreamConfig,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: None = None,
-        json_mode: bool = False,
-        client: _SyncBaseClientT = ...,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> SyncLLMFunctionDecorator[_BaseDynamicConfigT, Iterable[_ResponseModelT]]: ...
-
-    @overload
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: Literal[True] | StreamConfig,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT],
-        output_parser: Callable[[_BaseCallResponseT], _ParsedOutputT]
-        | Callable[[_BaseCallResponseChunkT], _ParsedOutputT]
-        | Callable[[_ResponseModelT], _ParsedOutputT]
-        | None,
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT
-        | _AsyncBaseClientT
-        | _SyncBaseClientT
-        | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> NoReturn: ...
-
-    def __call__(
-        self,
-        provider: Provider | LocalProvider,
-        model: str,
-        *,
-        stream: bool | StreamConfig = False,
-        tools: list[type[BaseTool] | Callable] | None = None,
-        response_model: type[_ResponseModelT] | None = None,
-        output_parser: Callable[[_BaseCallResponseT], _ParsedOutputT]
-        | Callable[[_BaseCallResponseChunkT], _ParsedOutputT]
-        | Callable[[_ResponseModelT], _ParsedOutputT]
-        | None = None,
-        json_mode: bool = False,
-        client: _SameSyncAndAsyncClientT
-        | _AsyncBaseClientT
-        | _SyncBaseClientT
-        | None = None,
-        call_params: _BaseCallParamsT | None = None,
-    ) -> (
-        AsyncLLMFunctionDecorator[
-            _AsyncBaseDynamicConfigT,
-            _BaseCallResponseT
-            | _ParsedOutputT
-            | _BaseStreamT
-            | _ResponseModelT
-            | AsyncIterable[_ResponseModelT],
-        ]
-        | SyncLLMFunctionDecorator[
-            _BaseDynamicConfigT,
-            _BaseCallResponseT
-            | _ParsedOutputT
-            | _BaseStreamT
-            | _ResponseModelT
-            | Iterable[_ResponseModelT],
-        ]
-        | LLMFunctionDecorator[
-            _BaseDynamicConfigT,
-            _AsyncBaseDynamicConfigT,
-            _BaseCallResponseT
-            | _ParsedOutputT
-            | _BaseStreamT
-            | _ResponseModelT
-            | Iterable[_ResponseModelT],
-            _BaseCallResponseT
-            | _ParsedOutputT
-            | _BaseStreamT
-            | _ResponseModelT
-            | AsyncIterable[_ResponseModelT],
-        ]
-    ): ...
-
-
-CallDecorator: TypeAlias = _CallDecorator[
-    CallResponse,
-    CallResponseChunk,
-    BaseDynamicConfig,
-    BaseDynamicConfig,
-    CommonCallParams,
-    Stream,
-    Any,
-    Any,
-    Any,
-]

mirascope/llm/_response_metaclass.py

@@ -1,31 +0,0 @@
-import inspect
-from functools import cached_property
-from typing import Any
-
-from pydantic._internal._model_construction import ModelMetaclass
-
-
-class _ResponseMetaclass(ModelMetaclass):
-    def __new__(
-        mcls,
-        name: str,
-        bases: tuple[type, ...],
-        namespace: dict[str, Any],
-        **kwargs: Any,  # noqa: ANN401
-    ) -> type:
-        cls = super().__new__(mcls, name, bases, namespace)
-        cls.__abstractmethods__ = frozenset()
-        cls._properties = []
-
-        for n, v in inspect.getmembers(cls):
-            if isinstance(v, property):
-                f = v.fget
-            elif isinstance(v, cached_property):
-                f = v.func
-            else:
-                continue
-
-            if not getattr(f, "__isabstractmethod__", False):
-                cls._properties.append(n)
-
-        return cls

mirascope/llm/call_response.py

@@ -1,167 +0,0 @@
-"""The CallResponse class for the LLM provider."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from functools import cached_property
-from typing import Any
-
-from pydantic import computed_field
-
-from ..core import BaseDynamicConfig
-from ..core.base import (
-    BaseCallParams,
-    BaseCallResponse,
-    BaseMessageParam,
-    BaseTool,
-    Usage,
-    transform_tool_outputs,
-)
-from ..core.base._utils import BaseMessageParamConverter
-from ..core.base.message_param import ToolResultPart
-from ..core.base.types import FinishReason
-from ._response_metaclass import _ResponseMetaclass
-from .tool import Tool
-
-
-class CallResponse(
-    BaseCallResponse[
-        Any,
-        BaseTool,
-        Any,
-        BaseDynamicConfig[Any, Any, Any],
-        BaseMessageParam,
-        BaseCallParams,
-        BaseMessageParam,
-        BaseMessageParamConverter,
-    ],
-    metaclass=_ResponseMetaclass,
-):
-    """
-    A provider-agnostic CallResponse class.
-
-    We rely on _response having `common_` methods or properties for normalization.
-    """
-
-    _response: BaseCallResponse[Any, BaseTool, Any, Any, Any, Any, Any, Any]
-
-    def __init__(
-        self,
-        response: BaseCallResponse[Any, BaseTool, Any, Any, Any, Any, Any, Any],
-    ) -> None:
-        super().__init__(
-            **{
-                field: getattr(response, field)
-                for field in response.model_fields
-                if field != "user_message_param"
-            }
-        )
-        object.__setattr__(self, "_response", response)
-        object.__setattr__(
-            self, "user_message_param", response.common_user_message_param
-        )
-        object.__setattr__(self, "messages", response.common_messages)
-
-    def __getattribute__(self, name: str) -> Any:  # noqa: ANN401
-        special_names = {
-            "_response",
-            "common_messages",
-            "finish_reasons",
-            "usage",
-            "message_param",
-            "user_message_param",
-            "messages",
-            "tools",
-            "tool",
-            "tool_message_params",
-            "__dict__",
-            "__class__",
-            "model_fields",
-            "__annotations__",
-            "__pydantic_validator__",
-            "__pydantic_fields_set__",
-            "__pydantic_extra__",
-            "__pydantic_private__",
-            "__class_getitem__",
-            "__repr__",
-            "__str__",
-            "_properties",
-        } | set(object.__getattribute__(self, "_properties"))
-
-        if name in special_names:
-            return object.__getattribute__(self, name)
-
-        try:
-            response = object.__getattribute__(self, "_response")
-            return getattr(response, name)
-        except AttributeError:
-            return object.__getattribute__(self, name)
-
-    def __str__(self) -> str:
-        return str(self._response)
-
-    @computed_field
-    @property
-    def finish_reasons(self) -> list[FinishReason] | None:  # pyright: ignore [reportIncompatibleMethodOverride]
-        return self._response.common_finish_reasons
-
-    @property
-    def usage(self) -> Usage | None:
-        """Returns the usage of the chat completion."""
-        return self._response.common_usage
-
-    @computed_field
-    @cached_property
-    def message_param(self) -> BaseMessageParam:
-        return self._response.common_message_param  # pyright: ignore [reportReturnType]
-
-    @computed_field
-    @cached_property
-    def common_messages(self) -> list[BaseMessageParam]:  # pyright: ignore [reportIncompatibleMethodOverride]
-        return self._response.common_messages
-
-    @cached_property
-    def tools(self) -> list[Tool] | None:  # pyright: ignore [reportIncompatibleVariableOverride]
-        return self._response.common_tools
-
-    @cached_property
-    def tool(self) -> Tool | None:  # pyright: ignore [reportIncompatibleVariableOverride]
-        tools = self._response.common_tools
-        if tools:
-            return tools[0]
-        return None
-
-    @classmethod
-    @transform_tool_outputs
-    def tool_message_params(
-        cls, tools_and_outputs: Sequence[tuple[BaseTool, str]]
-    ) -> list[BaseMessageParam]:
-        """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.
-        """
-
-        def _get_tool_call_id(_tool: BaseTool) -> str | None:
-            """Get the tool call ID."""
-            if tool_call := getattr(_tool, "tool_call", None):
-                # Expect tool_call has an id attribute.
-                # If not, we should implement a method to get the id on the provider tool
-                return getattr(tool_call, "id", None)
-            return None
-
-        return [
-            BaseMessageParam(
-                role="tool",
-                content=[
-                    ToolResultPart(
-                        type="tool_result",
-                        name=tool._name(),
-                        content=output,
-                        id=_get_tool_call_id(tool),
-                    )
-                ],
-            )
-            for tool, output in tools_and_outputs
-        ]