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

mirascope/core/base/_utils/_setup_call.py

@@ -1,79 +0,0 @@
-"""Utility for setting up a provider-specific call."""
-
-import inspect
-from collections.abc import (
-    Awaitable,
-    Callable,
-    Sequence,
-)
-from typing import Any, Protocol, TypeVar, cast
-
-from ..call_kwargs import BaseCallKwargs
-from ..call_params import BaseCallParams, CommonCallParams
-from ..dynamic_config import BaseDynamicConfig
-from ..message_param import BaseMessageParam
-from ..tool import BaseTool
-from . import get_prompt_template, parse_prompt_messages
-from ._convert_base_model_to_base_tool import convert_base_model_to_base_tool
-from ._convert_function_to_base_tool import convert_function_to_base_tool
-
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", bound=BaseDynamicConfig)
-_BaseCallParamsT = TypeVar("_BaseCallParamsT", bound=BaseCallParams, covariant=True)
-_CALL_PARAMS_KEYS = set(CommonCallParams.__annotations__)
-
-
-class ConvertCommonParamsFunc(Protocol[_BaseCallParamsT]):
-    def __call__(self, common_params: CommonCallParams) -> _BaseCallParamsT: ...
-
-
-def setup_call(
-    fn: Callable[..., _BaseDynamicConfigT | Awaitable[_BaseDynamicConfigT]]
-    | Callable[..., Sequence[BaseMessageParam]]
-    | Callable[..., Awaitable[Sequence[BaseMessageParam]]],
-    fn_args: dict[str, Any],
-    dynamic_config: _BaseDynamicConfigT,
-    tools: Sequence[type[BaseTool] | Callable] | None,
-    tool_type: type[_BaseToolT],
-    call_params: _BaseCallParamsT | CommonCallParams,
-    convert_common_call_params: ConvertCommonParamsFunc[_BaseCallParamsT],
-) -> tuple[
-    str | None,
-    list[BaseMessageParam | Any],
-    list[type[_BaseToolT]] | None,
-    BaseCallKwargs,
-]:
-    if isinstance(call_params, dict) and call_params.keys() <= _CALL_PARAMS_KEYS:
-        call_params = convert_common_call_params(cast(CommonCallParams, call_params))
-    call_kwargs = cast(BaseCallKwargs[_BaseToolT], dict(call_params))
-    prompt_template, messages = None, None
-    if dynamic_config is not None:
-        tools = dynamic_config.get("tools", tools)
-        messages = dynamic_config.get("messages", None)
-        if messages is not None and not isinstance(messages, list):
-            messages = list(messages)
-        dynamic_call_params = dynamic_config.get("call_params", None)
-        if dynamic_call_params:
-            call_kwargs |= dynamic_call_params
-
-    if not messages:
-        prompt_template = get_prompt_template(fn)
-        assert prompt_template is not None, "The function must have a prompt template."
-        messages = parse_prompt_messages(
-            roles=["system", "user", "assistant"],
-            template=prompt_template,
-            attrs=fn_args,
-            dynamic_config=dynamic_config,
-        )
-
-    tool_types = None
-    if tools:
-        tool_types = [
-            convert_base_model_to_base_tool(tool, tool_type)
-            if inspect.isclass(tool)
-            else convert_function_to_base_tool(tool, tool_type)
-            for tool in tools
-        ]
-        call_kwargs["tools"] = [tool_type.tool_schema() for tool_type in tool_types]
-
-    return prompt_template, messages, tool_types, call_kwargs

mirascope/core/base/_utils/_setup_extract_tool.py

@@ -1,30 +0,0 @@
-"""This module contains the `setup_extract_tool` function."""
-
-from abc import update_abstractmethods
-from typing import TypeVar
-
-from pydantic import BaseModel
-
-from ._base_type import BaseType, is_base_type
-from ._convert_base_model_to_base_tool import convert_base_model_to_base_tool
-from ._convert_base_type_to_base_tool import convert_base_type_to_base_tool
-
-BaseToolT = TypeVar("BaseToolT", bound=BaseModel)
-
-
-def setup_extract_tool(
-    response_model: type[BaseModel] | type[BaseType], tool_type: type[BaseToolT]
-) -> type[BaseToolT]:
-    if is_base_type(response_model):
-        converted_tool_type = convert_base_type_to_base_tool(response_model, tool_type)
-    elif issubclass(response_model, BaseModel):
-        converted_tool_type = convert_base_model_to_base_tool(response_model, tool_type)
-    else:  # pragma: no cover
-        # pyright should work with IsType for the case of BaseModel | BaseType
-        # But it doesn't, so we need to cover this
-        raise ValueError(
-            f"`response_model` must be a BaseModel or a BaseType, not `{response_model}`."
-        )
-    if not hasattr(response_model, "call"):
-        converted_tool_type.call = lambda self: ""  # pyright: ignore [reportAttributeAccessIssue]
-    return update_abstractmethods(converted_tool_type)

mirascope/core/base/call_kwargs.py

@@ -1,13 +0,0 @@
-"""This module contains the type definition for the base call keyword arguments."""
-
-from typing import Generic, TypeVar
-
-from typing_extensions import NotRequired
-
-from .call_params import BaseCallParams
-
-_ToolSchemaT = TypeVar("_ToolSchemaT")
-
-
-class BaseCallKwargs(BaseCallParams, Generic[_ToolSchemaT]):
-    tools: NotRequired[list[_ToolSchemaT]]

mirascope/core/base/call_params.py

@@ -1,36 +0,0 @@
-"""This module contains the type definition for the base call parameters."""
-
-from typing import TypeVar
-
-from typing_extensions import NotRequired, TypedDict
-
-
-class BaseCallParams(TypedDict, total=False): ...  # pragma: no cover
-
-
-_BaseCallParamsT = TypeVar("_BaseCallParamsT", bound=BaseCallParams)
-
-
-class CommonCallParams(TypedDict, total=False):
-    """Common parameters shared across LLM providers.
-
-    Note: Each provider may handle these parameters differently or not support them at all.
-    Please check provider-specific documentation for parameter support and behavior.
-
-    Attributes:
-        temperature: Controls randomness in the output (0.0 to 1.0).
-        max_tokens: Maximum number of tokens to generate.
-        top_p: Nucleus sampling parameter (0.0 to 1.0).
-        frequency_penalty: Penalizes frequent tokens (-2.0 to 2.0).
-        presence_penalty: Penalizes tokens based on presence (-2.0 to 2.0).
-        seed: Random seed for reproducibility.
-        stop: Stop sequence(s) to end generation.
-    """
-
-    temperature: NotRequired[float | None]
-    max_tokens: NotRequired[int | None]
-    top_p: NotRequired[float | None]
-    frequency_penalty: NotRequired[float | None]
-    presence_penalty: NotRequired[float | None]
-    seed: NotRequired[int | None]
-    stop: NotRequired[str | list[str] | None]

mirascope/core/base/call_response.py

@@ -1,338 +0,0 @@
-"""This module contains the base call response class."""
-
-from __future__ import annotations
-
-import base64
-import json
-from abc import ABC, abstractmethod
-from collections.abc import Callable, Sequence
-from functools import cached_property, wraps
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar, cast
-
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    FieldSerializationInfo,
-    SkipValidation,
-    computed_field,
-    field_serializer,
-)
-
-from ..costs import calculate_cost
-from ._utils import BaseMessageParamConverter, BaseType, get_common_usage
-from .call_kwargs import BaseCallKwargs
-from .call_params import BaseCallParams
-from .dynamic_config import BaseDynamicConfig
-from .metadata import Metadata
-from .tool import BaseTool
-from .types import CostMetadata, FinishReason, JsonableType, Provider, Usage
-
-if TYPE_CHECKING:
-    from ...llm.tool import Tool
-    from .. import BaseMessageParam
-
-_ResponseT = TypeVar("_ResponseT", bound=Any)
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-_ToolSchemaT = TypeVar("_ToolSchemaT")
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", bound=BaseDynamicConfig)
-_MessageParamT = TypeVar("_MessageParamT", bound=Any)
-_ToolMessageParamT = TypeVar("_ToolMessageParamT", bound=Any)
-_CallParamsT = TypeVar("_CallParamsT", bound=BaseCallParams)
-_UserMessageParamT = TypeVar("_UserMessageParamT", bound=Any)
-_BaseCallResponseT = TypeVar("_BaseCallResponseT", bound="BaseCallResponse")
-_BaseMessageParamConverterT = TypeVar(
-    "_BaseMessageParamConverterT", bound=BaseMessageParamConverter
-)
-
-
-def transform_tool_outputs(
-    fn: Callable[
-        [type[_BaseCallResponseT], Sequence[tuple[_BaseToolT, str]]],
-        list[_ToolMessageParamT],
-    ],
-) -> Callable[
-    [type[_BaseCallResponseT], Sequence[tuple[_BaseToolT, JsonableType]]],
-    list[_ToolMessageParamT],
-]:
-    @wraps(fn)
-    def wrapper(
-        cls: type[_BaseCallResponseT],
-        tools_and_outputs: Sequence[tuple[_BaseToolT, JsonableType]],
-    ) -> list[_ToolMessageParamT]:
-        def recursive_serializer(value: JsonableType) -> BaseType:
-            if isinstance(value, str | int | float | bool | None):
-                return value
-            if isinstance(value, bytes):
-                return base64.b64encode(value).decode("utf-8")
-            if isinstance(value, BaseModel):
-                return value.model_dump()
-            if isinstance(value, list | set | tuple):
-                return [recursive_serializer(item) for item in value]
-            if isinstance(value, dict):
-                return {k: recursive_serializer(v) for k, v in value.items()}
-            raise TypeError(f"Unsupported type for serialization: {type(value)}")
-
-        transformed_tools_and_outputs = [
-            (
-                tool,
-                output.model_dump_json()
-                if isinstance(output, BaseModel)
-                else str(recursive_serializer(output))
-                if isinstance(output, str | bytes)
-                else json.dumps(recursive_serializer(output)),
-            )
-            for tool, output in tools_and_outputs
-        ]
-        return fn(cls, transformed_tools_and_outputs)
-
-    return wrapper
-
-
-class BaseCallResponse(
-    BaseModel,
-    Generic[
-        _ResponseT,
-        _BaseToolT,
-        _ToolSchemaT,
-        _BaseDynamicConfigT,
-        _MessageParamT,
-        _CallParamsT,
-        _UserMessageParamT,
-        _BaseMessageParamConverterT,
-    ],
-    ABC,
-):
-    """A base abstract interface for LLM call responses.
-
-    Attributes:
-        metadata: The metadata pulled from the call that was made.
-        response: The original response from whichever model response this wraps.
-        tool_types: The list of tool types used, if any.
-        prompt_template: The unformatted prompt template from the call that was made.
-        fn_args: The input arguments used when making the call.
-        dynamic_config: Dynamic configuration options, if any.
-        messages: The list of provider-specific messages used to make the API call.
-        call_params: The original call params set in the call decorator.
-        call_kwargs: The keyword arguments used to make the API call.
-        user_message_param: The most recent provider-specific message if it was a user
-            message. Otherwise `None`.
-        start_time: The start time of the completion in ms.
-        end_time: The end time of the completion in ms.
-    """
-
-    metadata: Metadata
-    response: _ResponseT
-    tool_types: list[type[_BaseToolT]] | None = None
-    prompt_template: str | None
-    fn_args: dict[str, Any]
-    dynamic_config: _BaseDynamicConfigT
-    messages: SkipValidation[list[_MessageParamT]]
-    call_params: SkipValidation[_CallParamsT]
-    call_kwargs: BaseCallKwargs[_ToolSchemaT]
-    user_message_param: _UserMessageParamT | None = None
-    start_time: float
-    end_time: float
-
-    _message_converter: type[_BaseMessageParamConverterT]
-    _provider: ClassVar[str] = "NO PROVIDER"
-    _model: str = "NO MODEL"
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
-
-    @field_serializer("tool_types", when_used="json")
-    def serialize_tool_types(
-        self, tool_types: list[type[_BaseToolT]] | None, info: FieldSerializationInfo
-    ) -> list[dict[str, str]]:
-        return [{"type": "function", "name": tool._name()} for tool in tool_types or []]
-
-    def __str__(self) -> str:
-        """Returns the string content of the response."""
-        return self.content
-
-    @computed_field
-    @property
-    @abstractmethod
-    def content(self) -> str:
-        """Should return the string content of the response.
-
-        If there are multiple choices in a response, this method should select the 0th
-        choice and return it's string content.
-
-        If there is no string content (e.g. when using tools), this method must return
-        the empty string.
-        """
-        ...
-
-    @computed_field
-    @property
-    @abstractmethod
-    def finish_reasons(self) -> list[str] | None:
-        """Should return the finish reasons of the response.
-
-        If there is no finish reason, this method must return None.
-        """
-        ...
-
-    @computed_field
-    @property
-    @abstractmethod
-    def model(self) -> str | None:
-        """Should return the name of the response model."""
-        ...
-
-    @computed_field
-    @property
-    @abstractmethod
-    def id(self) -> str | None:
-        """Should return the id of the response."""
-        ...
-
-    @property
-    @abstractmethod
-    def usage(self) -> Any:  # noqa: ANN401
-        """Should return the usage of the response.
-
-        If there is no usage, this method must return None.
-        """
-        ...
-
-    @computed_field
-    @property
-    @abstractmethod
-    def input_tokens(self) -> int | float | None:
-        """Should return the number of input tokens.
-
-        If there is no input_tokens, this method must return None.
-        """
-        ...
-
-    @computed_field
-    @property
-    @abstractmethod
-    def cached_tokens(self) -> int | float | None:
-        """Should return the number of cached tokens.
-
-        If there is no cached_tokens, this method must return None.
-        """
-        ...
-
-    @computed_field
-    @property
-    @abstractmethod
-    def output_tokens(self) -> int | float | None:
-        """Should return the number of output tokens.
-
-        If there is no output_tokens, this method must return None.
-        """
-        ...
-
-    @computed_field
-    @property
-    @abstractmethod
-    def cost_metadata(self) -> CostMetadata:
-        """Get metadata required for cost calculation.
-
-        Returns:
-            Metadata relevant to cost calculation
-        """
-
-        return CostMetadata(
-            input_tokens=self.input_tokens,
-            output_tokens=self.output_tokens,
-            cached_tokens=self.cached_tokens,
-        )
-
-    @computed_field
-    @property
-    def cost(self) -> float | None:
-        """Calculate the cost of this API call using the unified calculate_cost function."""
-
-        model = self.model
-        if not model:
-            return None
-
-        if self.input_tokens is None or self.output_tokens is None:
-            return None
-
-        return calculate_cost(
-            provider=self.provider,
-            model=model,
-            metadata=self.cost_metadata,
-        )
-
-    @property
-    def provider(self) -> Provider:
-        """Get the provider used for this API call."""
-        return cast(Provider, self._provider)
-
-    @computed_field
-    @cached_property
-    @abstractmethod
-    def message_param(self) -> Any:  # noqa: ANN401
-        """Returns the assistant's response as a message parameter."""
-        ...
-
-    @cached_property
-    @abstractmethod
-    def tools(self) -> list[_BaseToolT] | None:
-        """Returns the tools for the 0th choice message."""
-        ...
-
-    @cached_property
-    @abstractmethod
-    def tool(self) -> _BaseToolT | None:
-        """Returns the 0th tool for the 0th choice message."""
-        ...
-
-    @classmethod
-    @abstractmethod
-    @transform_tool_outputs
-    def tool_message_params(
-        cls, tools_and_outputs: Sequence[tuple[_BaseToolT, str]]
-    ) -> list[Any]:
-        """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.
-        """
-        ...
-
-    @property
-    @abstractmethod
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        """Provider-agnostic finish reasons."""
-        ...
-
-    @property
-    @abstractmethod
-    def common_message_param(self) -> BaseMessageParam:
-        """Provider-agnostic assistant message param."""
-        ...
-
-    @property
-    @abstractmethod
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        """Provider-agnostic user message param."""
-        ...
-
-    @property
-    def common_messages(self) -> list[BaseMessageParam]:
-        """Provider-agnostic list of messages."""
-        return self._message_converter.from_provider(self.messages)
-
-    @property
-    def common_tools(self) -> list[Tool] | None:
-        """Provider-agnostic tools."""
-        from ...llm.tool import Tool
-
-        if not self.tools:
-            return None
-        return [Tool(tool=tool) for tool in self.tools]  # pyright: ignore [reportAbstractUsage]
-
-    @property
-    def common_usage(self) -> Usage | None:
-        """Provider-agnostic usage info."""
-        return get_common_usage(
-            self.input_tokens, self.cached_tokens, self.output_tokens
-        )

mirascope/core/base/call_response_chunk.py

@@ -1,130 +0,0 @@
-"""This module contains the `BaseCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any, Generic, TypeVar
-
-from pydantic import BaseModel, ConfigDict
-
-from mirascope.core.base._utils import get_common_usage
-from mirascope.core.base.types import CostMetadata, FinishReason, Usage
-
-_ChunkT = TypeVar("_ChunkT", bound=Any)
-_FinishReasonT = TypeVar("_FinishReasonT", bound=Any)
-
-
-class BaseCallResponseChunk(BaseModel, Generic[_ChunkT, _FinishReasonT], ABC):
-    """A base abstract interface for LLM streaming response chunks.
-
-    Attributes:
-        chunk: The original response chunk from whichever model response this wraps.
-    """
-
-    chunk: _ChunkT
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
-
-    def __str__(self) -> str:
-        """Returns the string content of the chunk."""
-        return self.content
-
-    @property
-    @abstractmethod
-    def content(self) -> str:
-        """Should return the string content of the response chunk.
-
-        If there are multiple choices in a chunk, this method should select the 0th
-        choice and return it's string content.
-
-        If there is no string content (e.g. when using tools), this method must return
-        the empty string.
-        """
-        ...
-
-    @property
-    @abstractmethod
-    def finish_reasons(self) -> list[_FinishReasonT] | None:
-        """Should return the finish reasons of the response.
-
-        If there is no finish reason, this method must return None.
-        """
-        ...
-
-    @property
-    @abstractmethod
-    def model(self) -> str | None:
-        """Should return the name of the response model."""
-        ...
-
-    @property
-    @abstractmethod
-    def id(self) -> str | None:
-        """Should return the id of the response."""
-        ...
-
-    @property
-    @abstractmethod
-    def usage(self) -> Any:  # noqa: ANN401
-        """Should return the usage of the response.
-
-        If there is no usage, this method must return None.
-        """
-        ...
-
-    @property
-    @abstractmethod
-    def input_tokens(self) -> int | float | None:
-        """Should return the number of input tokens.
-
-        If there is no input_tokens, this method must return None.
-        """
-        ...
-
-    @property
-    @abstractmethod
-    def cached_tokens(self) -> int | float | None:
-        """Should return the number of cached tokens.
-
-        If there is no cached_tokens, this method must return None.
-        """
-        ...
-
-    @property
-    @abstractmethod
-    def output_tokens(self) -> int | float | None:
-        """Should return the number of output tokens.
-
-        If there is no output_tokens, this method must return None.
-        """
-        ...
-
-    @property
-    @abstractmethod
-    def cost_metadata(self) -> CostMetadata:
-        """Get metadata required for cost calculation.
-
-        Returns:
-            A CostMetadata object with information relevant to cost calculation
-        """
-        return CostMetadata(
-            input_tokens=self.input_tokens,
-            output_tokens=self.output_tokens,
-            cached_tokens=self.cached_tokens,
-        )
-
-    @property
-    @abstractmethod
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        """Provider-agnostic finish reasons."""
-        ...
-
-    @property
-    def common_usage(self) -> Usage | None:
-        """Provider-agnostic usage info."""
-        return get_common_usage(
-            self.input_tokens, self.cached_tokens, self.output_tokens
-        )