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

mirascope/core/anthropic/call_params.py

@@ -1,36 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-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, Required
-
-from ..base import BaseCallParams
-
-
-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: ...
-        metadata: ...
-        stop_sequences: ...
-        temperature: ...
-        top_k: ...
-        top_p: ...
-        timeout: ...
-    """
-
-    max_tokens: Required[int]
-    tool_choice: NotRequired[ToolChoice | None]
-    metadata: NotRequired[Metadata | None]
-    stop_sequences: NotRequired[list[str] | 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,158 +0,0 @@
-"""This module contains the `AnthropicCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from anthropic.types import Message, MessageParam, ToolResultBlockParam, Usage
-from pydantic import SerializeAsAny, computed_field
-
-from ..base import BaseCallResponse
-from ._utils import calculate_cost
-from .call_params import AnthropicCallParams
-from .dynamic_config import AnthropicDynamicConfig
-from .tool import AnthropicTool
-
-
-class AnthropicCallResponse(
-    BaseCallResponse[
-        Message,
-        AnthropicTool,
-        AnthropicDynamicConfig,
-        MessageParam,
-        AnthropicCallParams,
-        MessageParam,
-    ]
-):
-    """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")
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")  # response is an `AnthropicCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _provider = "anthropic"
-
-    @property
-    def content(self) -> str:
-        """Returns the string text of the 0th text block."""
-        block = self.response.content[0]
-        return block.text if block.type == "text" else ""
-
-    @property
-    def finish_reasons(self) -> list[str]:
-        """Returns the finish reasons of the response."""
-        return [str(self.response.stop_reason)]
-
-    @property
-    def model(self) -> str:
-        """Returns the name of the response model."""
-        return self.response.model
-
-    @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
-
-    @property
-    def input_tokens(self) -> int:
-        """Returns the number of input tokens."""
-        return self.usage.input_tokens
-
-    @property
-    def output_tokens(self) -> int:
-        """Returns the number of output tokens."""
-        return self.usage.output_tokens
-
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(self.input_tokens, self.output_tokens, self.model)
-
-    @computed_field
-    @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"}))
-
-    @computed_field
-    @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
-
-    @computed_field
-    @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
-    def tool_message_params(
-        cls, tools_and_outputs: list[tuple[AnthropicTool, str]]
-    ) -> list[MessageParam]:
-        """Returns the tool message parameters for tool call results.
-
-        Args:
-            tools_and_outputs: The list 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,
-                        type="tool_result",
-                        content=[{"text": output, "type": "text"}],
-                    )
-                    for tool, output in tools_and_outputs
-                ],
-            }
-        ]

mirascope/core/anthropic/call_response_chunk.py

@@ -1,104 +0,0 @@
-"""This module contains the `AnthropicCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from anthropic.types import (
-    Message,
-    MessageDeltaUsage,
-    MessageStartEvent,
-    MessageStreamEvent,
-    RawMessageDeltaEvent,
-    RawMessageStartEvent,
-    Usage,
-)
-
-from ..base import BaseCallResponseChunk
-
-FinishReason = Message.__annotations__["stop_reason"]
-
-
-class AnthropicCallResponseChunk(
-    BaseCallResponseChunk[MessageStreamEvent, FinishReason]
-):
-    """A convenience wrapper around the Anthropic `ChatCompletionChunk` streamed chunks.
-
-    When calling the Anthropic API using a function decorated with `anthropic_call` and
-    `stream` set to `True`, the stream will contain `AnthropicResponseChunk` instances
-    with properties that allow for more convenient 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", stream=True)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # response is an `AnthropicStream`
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    @property
-    def content(self) -> str:
-        """Returns the string content of the 0th message."""
-        return (
-            self.chunk.delta.text
-            if self.chunk.type == "content_block_delta"
-            and self.chunk.delta.type == "text_delta"
-            else ""
-        )
-
-    @property
-    def finish_reasons(self) -> list[FinishReason] | None:
-        """Returns the finish reason of the response."""
-        if (
-            isinstance(self.chunk, RawMessageStartEvent)
-            and self.chunk.message.stop_reason
-        ):
-            return [str(self.chunk.message.stop_reason)]
-        return None
-
-    @property
-    def model(self) -> str | None:
-        """Returns the name of the response model."""
-        if isinstance(self.chunk, MessageStartEvent):
-            return self.chunk.message.model
-        return None
-
-    @property
-    def id(self) -> str | None:
-        """Returns the id of the response."""
-        if isinstance(self.chunk, MessageStartEvent):
-            return self.chunk.message.id
-        return None
-
-    @property
-    def usage(self) -> Usage | MessageDeltaUsage | None:
-        """Returns the usage of the message."""
-        if isinstance(self.chunk, MessageStartEvent):
-            return self.chunk.message.usage
-        elif isinstance(self.chunk, RawMessageDeltaEvent):
-            return self.chunk.usage
-        return None
-
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        if (usage := self.usage) and isinstance(usage, Usage):
-            return usage.input_tokens
-        return None
-
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        if self.usage:
-            return self.usage.output_tokens
-        return None

mirascope/core/anthropic/dynamic_config.py

@@ -1,26 +0,0 @@
-"""This module defines the function return type for functions as LLM calls.
-
-usage docs: learn/dynamic_configuration.md#dynamic-configuration-options
-"""
-
-from anthropic.types import MessageParam
-
-from ..base import BaseDynamicConfig
-from .call_params import AnthropicCallParams
-
-AnthropicDynamicConfig = BaseDynamicConfig[MessageParam, AnthropicCallParams]
-"""The function return type for functions wrapped with the `anthropic_call` decorator.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.anthropic import AnthropicDynamicConfig, anthropic_call
-
-
-@anthropic_call("claude-3-5-sonnet-20240620")
-@prompt_template("Recommend a {capitalized_genre} book")
-def recommend_book(genre: str) -> AnthropicDynamicConfig:
-    return {"computed_fields": {"capitalized_genre": genre.capitalize()}}
-```
-"""

mirascope/core/anthropic/stream.py

@@ -1,140 +0,0 @@
-"""The `AnthropicStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from anthropic.types import Message, MessageParam, TextBlock, ToolUseBlock, Usage
-from anthropic.types.content_block import ContentBlock
-from anthropic.types.text_block_param import TextBlockParam
-from anthropic.types.tool_use_block_param import ToolUseBlockParam
-from pydantic import BaseModel
-
-from ..base.stream import BaseStream
-from ._utils import calculate_cost
-from .call_params import AnthropicCallParams
-from .call_response import AnthropicCallResponse
-from .call_response_chunk import AnthropicCallResponseChunk
-from .dynamic_config import AnthropicDynamicConfig
-from .tool import AnthropicTool
-
-FinishReason = Message.__annotations__["stop_reason"]
-
-
-class AnthropicStream(
-    BaseStream[
-        AnthropicCallResponse,
-        AnthropicCallResponseChunk,
-        MessageParam,
-        MessageParam,
-        MessageParam,
-        MessageParam,
-        AnthropicTool,
-        AnthropicDynamicConfig,
-        AnthropicCallParams,
-        FinishReason,
-    ]
-):
-    """A class for convenience around streaming Anthropic LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.anthropic import anthropic_call
-
-
-    @anthropic_call("claude-3-5-sonnet-20240620", stream=True)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # returns `AnthropicStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "anthropic"
-
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(self.input_tokens, self.output_tokens, self.model)
-
-    def _construct_message_param(
-        self, tool_calls: list[ToolUseBlock] | None = None, content: str | None = None
-    ) -> MessageParam:
-        """Constructs the message parameter for the assistant."""
-        message_param_tool_calls = []
-        if tool_calls:
-            message_param_tool_calls: list[ToolUseBlockParam] = [
-                ToolUseBlockParam(
-                    id=tool_call.id,
-                    input=tool_call.input,
-                    name=tool_call.name,
-                    type="tool_use",
-                )
-                for tool_call in tool_calls
-            ]
-        return {
-            "role": "assistant",
-            "content": ([TextBlockParam(text=content, type="text")] if content else [])
-            + message_param_tool_calls,
-        }
-
-    def construct_call_response(self) -> AnthropicCallResponse:
-        """Constructs the call response from a consumed AnthropicStream.
-
-        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 = Usage(
-            input_tokens=int(self.input_tokens or 0),
-            output_tokens=int(self.output_tokens or 0),
-        )
-
-        content_blocks: list[ContentBlock] = []
-
-        if isinstance(self.message_param["content"], str):
-            content_blocks.append(
-                TextBlock(text=self.message_param["content"], type="text")
-            )
-        else:
-            for content in self.message_param["content"]:
-                content_type = (
-                    content.type if isinstance(content, BaseModel) else content["type"]
-                )
-
-                if content_type == "text":
-                    content_blocks.append(TextBlock.model_validate(content))
-                elif content_type == "tool_use":
-                    content_blocks.append(ToolUseBlock.model_validate(content))
-        completion = Message(
-            id=self.id if self.id else "",
-            content=content_blocks,
-            model=self.model,
-            role="assistant",
-            stop_reason=self.finish_reasons[0] if self.finish_reasons else None,
-            stop_sequence=None,
-            type="message",
-            usage=usage,
-        )
-        return AnthropicCallResponse(
-            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,
-        )

mirascope/core/anthropic/tool.py

@@ -1,77 +0,0 @@
-"""The `OpenAITool` class for easy tool usage with OpenAI LLM calls.
-
-usage docs: learn/tools.md#using-tools-with-standard-calls
-"""
-
-from __future__ import annotations
-
-import copy
-
-from anthropic.types import ToolParam, ToolUseBlock
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool
-
-
-class AnthropicTool(BaseTool):
-    """A class for defining tools for Anthropic LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.anthropic import anthropic_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @anthropic_call("claude-3-5-sonnet-20240620", tools=[format_book])
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `AnthropicTool` instance
-        print(tool.call())
-    ```
-    """
-
-    tool_call: SkipJsonSchema[ToolUseBlock]
-
-    @classmethod
-    def tool_schema(cls) -> ToolParam:
-        """Constructs a `ToolParam` tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.anthropic import AnthropicTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = AnthropicTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Anthropic-specific tool schema
-        ```
-        """
-        return ToolParam(
-            input_schema=cls.model_tool_schema(),
-            name=cls._name(),
-            description=cls._description(),
-        )
-
-    @classmethod
-    def from_tool_call(cls, tool_call: ToolUseBlock) -> AnthropicTool:
-        """Constructs an `AnthropicTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Anthropic tool call from which to construct this tool
-                instance.
-        """
-        model_json = copy.deepcopy(tool_call.input)
-        model_json["tool_call"] = tool_call.model_dump()  # type: ignore
-        return cls.model_validate(model_json)

mirascope/core/base/__init__.py

@@ -1,40 +0,0 @@
-"""Mirascope Base Classes."""
-
-from . import _partial, _utils
-from ._call_factory import call_factory
-from ._utils import BaseType
-from .call_params import BaseCallParams
-from .call_response import BaseCallResponse
-from .call_response_chunk import BaseCallResponseChunk
-from .dynamic_config import BaseDynamicConfig
-from .message_param import AudioPart, BaseMessageParam, ImagePart, TextPart
-from .metadata import Metadata
-from .prompt import BasePrompt, metadata, prompt_template
-from .stream import BaseStream
-from .structured_stream import BaseStructuredStream
-from .tool import BaseTool
-from .toolkit import BaseToolKit, toolkit_tool
-
-__all__ = [
-    "AudioPart",
-    "BaseCallParams",
-    "BaseCallResponse",
-    "BaseCallResponseChunk",
-    "BaseDynamicConfig",
-    "BaseMessageParam",
-    "BasePrompt",
-    "BaseStream",
-    "BaseStructuredStream",
-    "BaseTool",
-    "BaseToolKit",
-    "BaseType",
-    "call_factory",
-    "ImagePart",
-    "metadata",
-    "Metadata",
-    "prompt_template",
-    "TextPart",
-    "toolkit_tool",
-    "_partial",
-    "_utils",
-]