mirascope 1.25.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

mirascope/core/anthropic/call_response_chunk.py

@@ -1,152 +0,0 @@
-"""This module contains the `AnthropicCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from typing import cast
-
-from anthropic.types import (
-    Message,
-    MessageDeltaUsage,
-    MessageStartEvent,
-    MessageStreamEvent,
-    RawMessageDeltaEvent,
-    RawMessageStartEvent,
-    Usage,
-)
-
-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,
-)
-
-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)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    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 thinking(self) -> str:
-        """Returns the thinking content from thinking deltas."""
-        return (
-            self.chunk.delta.thinking
-            if self.chunk.type == "content_block_delta"
-            and self.chunk.delta.type == "thinking_delta"
-            else ""
-        )
-
-    @property
-    def signature(self) -> str:
-        """Returns the signature content from signature deltas."""
-        return (
-            self.chunk.delta.signature
-            if self.chunk.type == "content_block_delta"
-            and self.chunk.delta.type == "signature_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 cached_tokens(self) -> int | None:
-        """Returns the number of cached tokens."""
-        if (usage := self.usage) and isinstance(usage, Usage):
-            return getattr(usage, "cache_read_input_tokens", 0)
-        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
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Returns the cost metadata."""
-        return CostMetadata(
-            input_tokens=self.input_tokens,
-            output_tokens=self.output_tokens,
-            cached_tokens=self.cached_tokens,
-        )
-
-    @property
-    def common_finish_reasons(self) -> list[types.FinishReason] | None:
-        """Provider-agnostic finish reasons."""
-        return _convert_finish_reasons_to_common_finish_reasons(
-            cast(list[str], self.finish_reasons)
-        )

mirascope/core/anthropic/dynamic_config.py

@@ -1,40 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from anthropic import (
-    Anthropic,
-    AnthropicBedrock,
-    AnthropicVertex,
-    AsyncAnthropic,
-    AsyncAnthropicBedrock,
-    AsyncAnthropicVertex,
-)
-from anthropic.types import MessageParam
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import AnthropicCallParams
-
-AnthropicDynamicConfig = BaseDynamicConfig[
-    MessageParam | BaseMessageParam,
-    AnthropicCallParams,
-    Anthropic | AnthropicBedrock | AnthropicVertex,
-]
-AsyncAnthropicDynamicConfig = BaseDynamicConfig[
-    MessageParam | BaseMessageParam,
-    AnthropicCallParams,
-    AsyncAnthropic | AsyncAnthropicBedrock | AsyncAnthropicVertex,
-]
-"""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,204 +0,0 @@
-"""The `AnthropicStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from collections.abc import AsyncGenerator, Generator
-from typing import Any
-
-from anthropic.types import (
-    Message,
-    MessageParam,
-    TextBlock,
-    ToolParam,
-    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.call_kwargs import BaseCallKwargs
-from ..base.metadata import Metadata
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from ._thinking import ThinkingBlock
-from .call_params import AnthropicCallParams
-from .call_response import AnthropicCallResponse
-from .call_response_chunk import AnthropicCallResponseChunk
-from .dynamic_config import AnthropicDynamicConfig, AsyncAnthropicDynamicConfig
-from .tool import AnthropicTool
-
-FinishReason = Message.__annotations__["stop_reason"]
-
-
-class AnthropicStream(
-    BaseStream[
-        AnthropicCallResponse,
-        AnthropicCallResponseChunk,
-        MessageParam,
-        MessageParam,
-        MessageParam,
-        MessageParam,
-        AnthropicTool,
-        ToolParam,
-        AsyncAnthropicDynamicConfig | 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)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    stream = recommend_book("fantasy")  # returns `AnthropicStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "anthropic"
-
-    def __init__(
-        self,
-        *,
-        stream: Generator[
-            tuple[AnthropicCallResponseChunk, AnthropicTool | None], None, None
-        ]
-        | AsyncGenerator[tuple[AnthropicCallResponseChunk, AnthropicTool | None], None],
-        metadata: Metadata,
-        tool_types: list[type[AnthropicTool]] | None,
-        call_response_type: type[AnthropicCallResponse],
-        model: str,
-        prompt_template: str | None,
-        fn_args: dict[str, Any],
-        dynamic_config: AsyncAnthropicDynamicConfig | AnthropicDynamicConfig,
-        messages: list[MessageParam],
-        call_params: AnthropicCallParams,
-        call_kwargs: BaseCallKwargs[ToolParam],
-    ) -> None:
-        """Initialize AnthropicStream with thinking content tracking."""
-        super().__init__(
-            stream=stream,
-            metadata=metadata,
-            tool_types=tool_types,
-            call_response_type=call_response_type,
-            model=model,
-            prompt_template=prompt_template,
-            fn_args=fn_args,
-            dynamic_config=dynamic_config,
-            messages=messages,
-            call_params=call_params,
-            call_kwargs=call_kwargs,
-        )
-        self.thinking = ""
-        self.signature = ""
-
-    def _update_properties(self, chunk: AnthropicCallResponseChunk) -> None:
-        """Updates the properties of the stream, including thinking content."""
-        super()._update_properties(chunk)
-        self.thinking += chunk.thinking
-        self.signature += chunk.signature
-
-    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] = []
-
-        # Add thinking block first if we have thinking content
-        if hasattr(self, "thinking") and self.thinking:
-            content_blocks.append(
-                ThinkingBlock(  # pyright: ignore [reportArgumentType]
-                    type="thinking",
-                    thinking=self.thinking,
-                    signature=getattr(self, "signature", ""),
-                )
-            )
-
-        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,
-        )
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Get metadata required for cost calculation."""
-        return super().cost_metadata

mirascope/core/anthropic/tool.py

@@ -1,101 +0,0 @@
-"""The `OpenAITool` class for easy tool usage with OpenAI LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-from typing import Any, cast
-
-from anthropic.types import ToolParam, ToolUseBlock
-from pydantic.json_schema import SkipJsonSchema
-from typing_extensions import TypedDict
-
-from ..base import BaseTool, ToolConfig
-from ..base._partial import partial
-
-
-class _CacheControl(TypedDict):
-    type: str
-
-
-class AnthropicToolConfig(ToolConfig, total=False):
-    """A tool configuration for Anthropic-specific features."""
-
-    cache_control: _CacheControl
-
-
-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])
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `AnthropicTool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "anthropic"
-    __tool_config_type__ = AnthropicToolConfig
-
-    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
-        ```
-        """
-        kwargs = {
-            "input_schema": cls.model_json_schema(),
-            "name": cls._name(),
-            "description": cls._description(),
-        }
-        if "cache_control" in cls.tool_config:
-            kwargs["cache_control"] = cls.tool_config["cache_control"]
-        return ToolParam(**kwargs)
-
-    @classmethod
-    def from_tool_call(
-        cls, tool_call: ToolUseBlock, allow_partial: bool = False
-    ) -> 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 = {"tool_call": tool_call}
-        model_json |= (
-            cls._dict_from_json(tool_call.input, True)
-            if isinstance(tool_call.input, str)
-            else cast(dict[str, Any], tool_call.input)
-        )
-        if allow_partial:
-            return partial(cls, {"tool_call", "delta"}).model_validate(model_json)
-        return cls.model_validate(model_json)

mirascope/core/azure/__init__.py

@@ -1,31 +0,0 @@
-"""The Mirascope Azure Module."""
-
-from typing import TypeAlias
-
-from azure.ai.inference.models import ChatRequestMessage
-
-from ..base import BaseMessageParam
-from ._call import azure_call
-from ._call import azure_call as call
-from .call_params import AzureCallParams
-from .call_response import AzureCallResponse
-from .call_response_chunk import AzureCallResponseChunk
-from .dynamic_config import AsyncAzureDynamicConfig, AzureDynamicConfig
-from .stream import AzureStream
-from .tool import AzureTool, AzureToolConfig
-
-AzureMessageParam: TypeAlias = ChatRequestMessage | BaseMessageParam
-
-__all__ = [
-    "AsyncAzureDynamicConfig",
-    "AzureCallParams",
-    "AzureCallResponse",
-    "AzureCallResponseChunk",
-    "AzureDynamicConfig",
-    "AzureMessageParam",
-    "AzureStream",
-    "AzureTool",
-    "AzureToolConfig",
-    "azure_call",
-    "call",
-]

mirascope/core/azure/_call.py

@@ -1,67 +0,0 @@
-"""The `azure_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 AzureCallParams
-from .call_response import AzureCallResponse
-from .call_response_chunk import AzureCallResponseChunk
-from .stream import AzureStream
-from .tool import AzureTool
-
-azure_call = call_factory(
-    TCallResponse=AzureCallResponse,
-    TCallResponseChunk=AzureCallResponseChunk,
-    TToolType=AzureTool,
-    TStream=AzureStream,
-    default_call_params=AzureCallParams(),
-    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 Azure API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Azure 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.azure import azure_call
-
-
-@azure_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 Azure 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 Azure API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[AzureCallResponse | 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 (AzureCallParams): The `AzureCallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into an Azure API
-        call.
-"""

mirascope/core/azure/_call_kwargs.py

@@ -1,13 +0,0 @@
-"""This module contains the type definition for the Azure call keyword arguments."""
-
-from collections.abc import Sequence
-
-from azure.ai.inference.models import ChatCompletionsToolDefinition, ChatRequestMessage
-
-from ..base import BaseCallKwargs
-from .call_params import AzureCallParams
-
-
-class AzureCallKwargs(AzureCallParams, BaseCallKwargs[ChatCompletionsToolDefinition]):
-    model: str
-    messages: Sequence[ChatRequestMessage]

mirascope/core/azure/_utils/__init__.py

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

mirascope/core/azure/_utils/_convert_common_call_params.py

@@ -1,26 +0,0 @@
-from typing import cast
-
-from ...base.call_params import CommonCallParams
-from ..call_params import AzureCallParams
-
-AZURE_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "max_tokens",
-    "top_p": "top_p",
-    "frequency_penalty": "frequency_penalty",
-    "presence_penalty": "presence_penalty",
-    "seed": "seed",
-    "stop": "stop",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> AzureCallParams:
-    """Convert CommonCallParams to Azure parameters."""
-    return cast(
-        AzureCallParams,
-        {
-            AZURE_PARAM_MAPPING[key]: [value] if isinstance(value, str) else value
-            for key, value in common_params.items()
-            if key in AZURE_PARAM_MAPPING and AZURE_PARAM_MAPPING[key] is not None
-        },
-    )

mirascope/core/azure/_utils/_convert_finish_reason_to_common_finish_reasons.py

@@ -1,21 +0,0 @@
-from mirascope.core.base._utils._convert_provider_finish_reason_to_finish_reason import (
-    FinishReasonMappingValue,
-    _convert_finish_reasons_to_common_finish_reasons_from_mapping,
-)
-from mirascope.core.base.types import FinishReason
-
-_FinishReasonMapping: dict[str, FinishReasonMappingValue] = {
-    "CompletionsFinishReason.STOPPED": "stop",
-    "CompletionsFinishReason.TOKEN_LIMIT_REACHED": "length",
-    "CompletionsFinishReason.CONTENT_FILTERED": "content_filter",
-    "CompletionsFinishReason.TOOL_CALLS": "tool_calls",
-}
-
-
-def _convert_finish_reasons_to_common_finish_reasons(
-    finish_reasons: list[str],
-) -> list[FinishReason] | None:
-    """Provider-agnostic finish reasons."""
-    return _convert_finish_reasons_to_common_finish_reasons_from_mapping(
-        finish_reasons, _FinishReasonMapping
-    )