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

mirascope/core/anthropic/_utils/_handle_stream.py

@@ -1,113 +0,0 @@
-"""Utilities for handling a stream of messages."""
-
-from collections.abc import AsyncGenerator, Generator
-
-import jiter
-from anthropic.types import MessageStreamEvent, ToolUseBlock
-
-from ..call_response_chunk import AnthropicCallResponseChunk
-from ..tool import AnthropicTool
-
-
-def _handle_chunk(
-    buffer: str,
-    chunk: MessageStreamEvent,
-    current_tool_call: ToolUseBlock,
-    current_tool_type: type[AnthropicTool] | None,
-    tool_types: list[type[AnthropicTool]] | None,
-    partial_tools: bool = False,
-) -> tuple[
-    str,
-    AnthropicTool | None,
-    ToolUseBlock,
-    type[AnthropicTool] | None,
-]:
-    """Handles a chunk of the stream."""
-    if not tool_types:
-        return buffer, None, current_tool_call, current_tool_type
-
-    if chunk.type == "content_block_stop" and current_tool_type and buffer:
-        current_tool_call.input = jiter.from_json(buffer.encode())
-        return (
-            "",
-            current_tool_type.from_tool_call(current_tool_call),
-            ToolUseBlock(id="", input={}, name="", type="tool_use"),
-            None,
-        )
-
-    if chunk.type == "content_block_start" and isinstance(
-        chunk.content_block, ToolUseBlock
-    ):
-        content_block = chunk.content_block
-        current_tool_type = None
-        for tool_type in tool_types:
-            if tool_type._name() == content_block.name:
-                current_tool_type = tool_type
-                break
-        if current_tool_type is None:
-            raise RuntimeError(
-                f"Unknown tool type in stream: {content_block.name}."
-            )  # pragma: no cover
-        return (
-            "",
-            None,
-            ToolUseBlock(
-                id=content_block.id, input={}, name=content_block.name, type="tool_use"
-            ),
-            current_tool_type,
-        )
-
-    if chunk.type == "content_block_delta" and chunk.delta.type == "input_json_delta":
-        buffer += chunk.delta.partial_json
-
-        # Return partial tool if enabled
-        if partial_tools and current_tool_type:
-            partial_tool_call = ToolUseBlock(
-                id=current_tool_call.id,
-                input=buffer,
-                name=current_tool_call.name,
-                type="tool_use",
-            )
-            partial_tool = current_tool_type.from_tool_call(partial_tool_call, True)
-            partial_tool.delta = chunk.delta.partial_json
-            return buffer, partial_tool, current_tool_call, current_tool_type
-    return buffer, None, current_tool_call, current_tool_type
-
-
-def handle_stream(
-    stream: Generator[MessageStreamEvent, None, None],
-    tool_types: list[type[AnthropicTool]] | None,
-    partial_tools: bool = False,
-) -> Generator[tuple[AnthropicCallResponseChunk, AnthropicTool | None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ToolUseBlock(id="", input={}, name="", type="tool_use")
-    current_tool_type, buffer = None, ""
-    for chunk in stream:
-        buffer, tool, current_tool_call, current_tool_type = _handle_chunk(
-            buffer,
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-            partial_tools,
-        )
-        yield AnthropicCallResponseChunk(chunk=chunk), tool
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[MessageStreamEvent, None],
-    tool_types: list[type[AnthropicTool]] | None,
-    partial_tools: bool = False,
-) -> AsyncGenerator[tuple[AnthropicCallResponseChunk, AnthropicTool | None], None]:
-    current_tool_call = ToolUseBlock(id="", input={}, name="", type="tool_use")
-    current_tool_type, buffer = None, ""
-    async for chunk in stream:
-        buffer, tool, current_tool_call, current_tool_type = _handle_chunk(
-            buffer,
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-            partial_tools,
-        )
-        yield AnthropicCallResponseChunk(chunk=chunk), tool

mirascope/core/anthropic/_utils/_message_param_converter.py

@@ -1,154 +0,0 @@
-import base64
-import logging
-from os import PathLike
-from typing import cast
-
-from anthropic.types import MessageParam
-
-from mirascope.core import BaseMessageParam
-from mirascope.core.anthropic._utils import convert_message_params
-from mirascope.core.base import (
-    ImagePart,
-    ImageURLPart,
-    TextPart,
-    ToolCallPart,
-    ToolResultPart,
-)
-from mirascope.core.base._utils._base_message_param_converter import (
-    BaseMessageParamConverter,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class AnthropicMessageParamConverter(BaseMessageParamConverter):
-    """Converts between Anthropic `MessageParam` objects and Mirascope `BaseMessageParam`."""
-
-    @staticmethod
-    def to_provider(message_params: list[BaseMessageParam]) -> list[MessageParam]:
-        """
-        Convert from Mirascope `BaseMessageParam` to Anthropic's `MessageParam`.
-        """
-        return convert_message_params(
-            cast(list[BaseMessageParam | MessageParam], message_params)
-        )
-
-    @staticmethod
-    def from_provider(message_params: list[MessageParam]) -> list[BaseMessageParam]:
-        """
-        Convert from Anthropic's `MessageParam` back to Mirascope `BaseMessageParam`.
-        """
-        converted: list[BaseMessageParam] = []
-        for message_param in message_params:
-            content = message_param["content"]
-            if isinstance(content, str):
-                converted.append(
-                    BaseMessageParam(role=message_param["role"], content=content)
-                )
-                continue
-            converted_content = []
-
-            for block in content:
-                if not isinstance(block, dict):
-                    continue
-
-                if block["type"] == "text":
-                    text = block.get("text")
-                    if not isinstance(text, str):
-                        raise ValueError(
-                            "TextBlockParam must have a string 'text' field."
-                        )
-                    converted_content.append(TextPart(type="text", text=text))
-
-                elif block["type"] == "image":
-                    source = block.get("source")
-                    source_type = source.get("type") if source else None
-                    if not source or source_type not in ["base64", "url"]:
-                        raise ValueError(
-                            "ImageBlockParam must have a 'source' with type='base64' or type='url'."
-                        )
-                    if source_type == "url":
-                        url = source.get("url")
-                        if not url:
-                            raise ValueError(
-                                "ImageBlockParam source with type='url' must have a 'url'."
-                            )
-                        converted_content.append(
-                            ImageURLPart(type="image_url", url=url, detail=None)
-                        )
-                    else:
-                        image_data = source.get("data")
-                        media_type = source.get("media_type")
-                        if not image_data or not media_type:
-                            raise ValueError(
-                                "ImageBlockParam source with type='base64' must have 'data' and 'media_type'."
-                            )
-                        if media_type not in [
-                            "image/jpeg",
-                            "image/png",
-                            "image/gif",
-                            "image/webp",
-                        ]:
-                            raise ValueError(
-                                f"Unsupported image media type: {media_type}. "
-                                "BaseMessageParam currently only supports JPEG, PNG, GIF, and WebP images."
-                            )
-                        if isinstance(image_data, str):
-                            decoded_image_data = base64.b64decode(image_data)
-                        elif isinstance(image_data, PathLike):
-                            with open(image_data, "rb") as image_data:
-                                decoded_image_data = image_data.read()
-                        else:
-                            decoded_image_data = image_data.read()
-                        converted_content.append(
-                            ImagePart(
-                                type="image",
-                                media_type=media_type,
-                                image=decoded_image_data,
-                                detail=None,
-                            )
-                        )
-
-                elif block["type"] == "tool_use":
-                    converted_content.append(
-                        ToolCallPart(
-                            type="tool_call",
-                            args=cast(dict, block["input"]),
-                            id=block["id"],
-                            name=block["name"],
-                        )
-                    )
-                elif block["type"] == "tool_result":
-                    converted_content.append(
-                        ToolResultPart(
-                            type="tool_result",
-                            content=block["content"]  # pyright: ignore [reportTypedDictNotRequiredAccess]
-                            if isinstance(block["content"], str)  # pyright: ignore [reportTypedDictNotRequiredAccess]
-                            else list(block["content"])[0]["text"],  # pyright: ignore [reportTypedDictNotRequiredAccess, reportGeneralTypeIssues]
-                            id=block["tool_use_id"],
-                            is_error=block.get("is_error", False),
-                        )
-                    )
-                elif block["type"] in [
-                    "thinking",
-                    "redacted_thinking",
-                ]:  # pragma: no cover
-                    logger.warning(
-                        "Dropping thinking content blocks as they are not supported at "
-                        "the provider agnostic level in v1. For native thinking support "
-                        "check out [v2](https://mirascope.com/docs/mirascope/v2)"
-                    )
-                else:
-                    # Any other block type is not supported
-                    raise ValueError(
-                        f"Unsupported block type '{block['type']}'. "
-                        "BaseMessageParam currently only supports text and image parts."
-                    )
-            if converted_content:
-                converted.append(
-                    BaseMessageParam(
-                        role=message_param["role"], content=converted_content
-                    )
-                )
-
-        return converted

mirascope/core/anthropic/_utils/_setup_call.py

@@ -1,146 +0,0 @@
-"""This module contains the setup_call function for the Anthropic API."""
-
-import inspect
-from collections.abc import Awaitable, Callable
-from typing import Any, cast, overload
-
-from anthropic import (
-    Anthropic,
-    AnthropicBedrock,
-    AnthropicVertex,
-    AsyncAnthropic,
-    AsyncAnthropicBedrock,
-    AsyncAnthropicVertex,
-)
-from anthropic.types import Message, MessageParam, MessageStreamEvent
-from pydantic import BaseModel
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ...base._utils import AsyncCreateFn, CreateFn
-from ...base.stream_config import StreamConfig
-from .._call_kwargs import AnthropicCallKwargs
-from .._thinking import HAS_THINKING_SUPPORT
-from ..call_params import AnthropicCallParams
-from ..dynamic_config import AnthropicDynamicConfig, AsyncAnthropicDynamicConfig
-from ..tool import AnthropicTool
-from ._convert_common_call_params import convert_common_call_params
-from ._convert_message_params import convert_message_params
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: AsyncAnthropic | AsyncAnthropicBedrock | AsyncAnthropicVertex | None,
-    fn: Callable[..., Awaitable[AsyncAnthropicDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: AsyncAnthropicDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: AnthropicCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[Message, MessageStreamEvent],
-    str | None,
-    list[MessageParam],
-    list[type[AnthropicTool]] | None,
-    AnthropicCallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: Anthropic | AnthropicBedrock | AnthropicVertex | None,
-    fn: Callable[..., AnthropicDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: AnthropicDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: AnthropicCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[Message, MessageStreamEvent],
-    str | None,
-    list[MessageParam],
-    list[type[AnthropicTool]] | None,
-    AnthropicCallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: Anthropic
-    | AsyncAnthropic
-    | AnthropicBedrock
-    | AsyncAnthropicBedrock
-    | AnthropicVertex
-    | AsyncAnthropicVertex
-    | None,
-    fn: Callable[..., AnthropicDynamicConfig | Awaitable[AsyncAnthropicDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: AsyncAnthropicDynamicConfig | AnthropicDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: AnthropicCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    Callable[..., Message | Awaitable[Message]],
-    str | None,
-    list[MessageParam],
-    list[type[AnthropicTool]] | None,
-    AnthropicCallKwargs,
-]:
-    thinking_enabled = call_params.get("thinking") is not None
-
-    # Validate thinking parameter before processing
-    if thinking_enabled and not HAS_THINKING_SUPPORT:
-        raise ValueError(  # pragma: no cover
-            "Thinking parameter requires anthropic>=0.47.0. "
-            "Please upgrade: pip install 'anthropic>=0.47.0'"
-        )
-
-    prompt_template, messages, tool_types, base_call_kwargs = _utils.setup_call(
-        fn,
-        fn_args,
-        dynamic_config,
-        tools,
-        AnthropicTool,
-        call_params,
-        convert_common_call_params,
-    )
-    call_kwargs = cast(AnthropicCallKwargs, base_call_kwargs)
-    messages = cast(list[BaseMessageParam | MessageParam], messages)
-    messages = convert_message_params(messages)
-
-    if messages[0]["role"] == "system":
-        call_kwargs["system"] = messages.pop(0)["content"]  # pyright: ignore [reportGeneralTypeIssues]
-
-    use_json_mode = json_mode or (response_model and thinking_enabled)
-
-    if use_json_mode:
-        json_mode_content = _utils.json_mode_content(response_model)
-        if isinstance(messages[-1]["content"], str):
-            messages[-1]["content"] += json_mode_content
-        else:
-            messages[-1]["content"] = list(messages[-1]["content"]) + [
-                {"type": "text", "text": json_mode_content}
-            ]
-    elif response_model:
-        assert tool_types, "At least one tool must be provided for extraction."
-        call_kwargs["tool_choice"] = {"type": "tool", "name": tool_types[0]._name()}
-    call_kwargs |= {
-        "model": model,
-        "messages": messages,
-        "max_tokens": call_kwargs["max_tokens"],
-    }
-
-    if client is None:
-        client = AsyncAnthropic() if inspect.iscoroutinefunction(fn) else Anthropic()
-    create = client.messages.create
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/anthropic/call_params.py

@@ -1,44 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-
-from anthropic.types import TextBlockParam
-from anthropic.types.completion_create_params import Metadata
-from anthropic.types.message_create_params import ToolChoice
-from httpx import Timeout
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-from ._thinking import ThinkingConfigParam
-
-
-class AnthropicCallParams(BaseCallParams):
-    """The parameters to use when calling the Anthropic API.
-
-    [Anthropic API Reference](https://docs.anthropic.com/en/api/messages)
-
-    Attributes:
-        max_tokens: ...
-        tool_choice: ...
-        thinking: ...
-        metadata: ...
-        stop_sequences: ...
-        temperature: ...
-        top_k: ...
-        top_p: ...
-        timeout: ...
-    """
-
-    extra_headers: NotRequired[dict[str, str] | None]
-    max_tokens: int
-    tool_choice: NotRequired[ToolChoice | None]
-    thinking: NotRequired[ThinkingConfigParam | None]
-    metadata: NotRequired[Metadata | None]
-    stop_sequences: NotRequired[list[str] | None]
-    system: NotRequired[str | Iterable[TextBlockParam] | None]
-    temperature: NotRequired[float | None]
-    top_k: NotRequired[int | None]
-    top_p: NotRequired[float | None]
-    timeout: NotRequired[float | Timeout | None]

mirascope/core/anthropic/call_response.py

@@ -1,226 +0,0 @@
-"""This module contains the `AnthropicCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-
-from anthropic.types import (
-    Message,
-    MessageParam,
-    ToolParam,
-    ToolResultBlockParam,
-    Usage,
-)
-from pydantic import SerializeAsAny, computed_field
-
-from .. import BaseMessageParam
-from ..base import BaseCallResponse, transform_tool_outputs, types
-from ..base.types import CostMetadata
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-from ._utils._message_param_converter import AnthropicMessageParamConverter
-from .call_params import AnthropicCallParams
-from .dynamic_config import AnthropicDynamicConfig, AsyncAnthropicDynamicConfig
-from .tool import AnthropicTool
-
-
-class AnthropicCallResponse(
-    BaseCallResponse[
-        Message,
-        AnthropicTool,
-        ToolParam,
-        AsyncAnthropicDynamicConfig | AnthropicDynamicConfig,
-        MessageParam,
-        AnthropicCallParams,
-        MessageParam,
-        AnthropicMessageParamConverter,
-    ]
-):
-    """A convenience wrapper around the Anthropic `Message` response.
-
-    When calling the Anthropic API using a function decorated with `anthropic_call`, the
-    response will be an `AnthropicCallResponse` instance with properties that allow for
-    more convenience access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.anthropic import anthropic_call
-
-
-    @anthropic_call("claude-3-5-sonnet-20240620")
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")  # response is an `AnthropicCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _message_converter: type[AnthropicMessageParamConverter] = (
-        AnthropicMessageParamConverter
-    )
-
-    _provider = "anthropic"
-
-    @computed_field
-    @property
-    def content(self) -> str:
-        """Returns the text content from the first text block."""
-        for block in self.response.content:
-            if block.type == "text":
-                return block.text
-        return ""
-
-    @computed_field
-    @property
-    def thinking(self) -> str | None:
-        """Returns the thinking content from the first thinking block."""
-        for block in self.response.content:
-            if block.type == "thinking":
-                return block.thinking
-        return None
-
-    @computed_field
-    @property
-    def signature(self) -> str | None:
-        """Returns the signature from the first thinking block."""
-        for block in self.response.content:
-            if block.type == "thinking":
-                return block.signature
-        return None
-
-    @computed_field
-    @property
-    def finish_reasons(self) -> list[str]:
-        """Returns the finish reasons of the response."""
-        return [str(self.response.stop_reason)]
-
-    @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) -> Usage:
-        """Returns the usage of the message."""
-        return self.response.usage
-
-    @computed_field
-    @property
-    def input_tokens(self) -> int:
-        """Returns the number of input tokens."""
-        return self.usage.input_tokens
-
-    @computed_field
-    @property
-    def cached_tokens(self) -> int:
-        """Returns the number of cached tokens."""
-        return getattr(self.usage, "cache_read_input_tokens", 0)
-
-    @computed_field
-    @property
-    def output_tokens(self) -> int:
-        """Returns the number of output tokens."""
-        return self.usage.output_tokens
-
-    @computed_field
-    @cached_property
-    def message_param(self) -> SerializeAsAny[MessageParam]:
-        """Returns the assistants's response as a message parameter."""
-        return MessageParam(**self.response.model_dump(include={"content", "role"}))
-
-    @cached_property
-    def tools(self) -> list[AnthropicTool] | None:
-        """Returns any available tool calls as their `AnthropicTool` definition.
-
-        Raises:
-            ValidationError: if a tool call doesn't match the tool's schema.
-        """
-        if not self.tool_types:
-            return None
-
-        extracted_tools = []
-        for content in self.response.content:
-            if content.type != "tool_use":
-                continue
-            for tool_type in self.tool_types:
-                if content.name == tool_type._name():
-                    extracted_tools.append(tool_type.from_tool_call(content))
-                    break
-
-        return extracted_tools
-
-    @cached_property
-    def tool(self) -> AnthropicTool | 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[AnthropicTool, str]]
-    ) -> list[MessageParam]:
-        """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 `MessageParam` parameters.
-        """
-        return [
-            {
-                "role": "user",
-                "content": [
-                    ToolResultBlockParam(
-                        tool_use_id=tool.tool_call.id,  # pyright: ignore [reportOptionalMemberAccess]
-                        type="tool_result",
-                        content=[{"text": output, "type": "text"}],
-                    )
-                    for tool, output in tools_and_outputs
-                ],
-            }
-        ]
-
-    @property
-    def common_finish_reasons(self) -> list[types.FinishReason] | None:
-        """Provider-agnostic finish reasons."""
-        return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
-
-    @property
-    def common_message_param(self) -> BaseMessageParam:
-        return AnthropicMessageParamConverter.from_provider([(self.message_param)])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return AnthropicMessageParamConverter.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