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

mirascope/core/bedrock/call_params.py

@@ -1,38 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-from typing import Any
-
-from mypy_boto3_bedrock_runtime.type_defs import (
-    GuardrailConfigurationTypeDef,
-    InferenceConfigurationTypeDef,
-    SystemContentBlockTypeDef,
-    ToolConfigurationTypeDef,
-)
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-
-class BedrockCallParams(BaseCallParams):
-    """The parameters to use when calling the Bedrock API.
-
-    [Bedrock converse API Reference](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-runtime/client/converse.html)
-
-    Attributes:
-        system (Sequence[SystemContentBlockTypeDef]): The system content blocks to use in the API call.
-        inferenceConfig (InferenceConfigurationTypeDef): The inference configuration to use in the API call.
-        toolConfig (ToolConfigurationTypeDef): The tool configuration to use in the API call.
-        guardrailConfig (GuardrailConfigurationTypeDef): The guardrail configuration to use in the API call.
-        additionalModelRequestFields (Mapping[str, Any]): Additional model request fields to use in the API call.
-        additionalModelResponseFieldPaths (Sequence[str]): Additional model response field paths to use in the API call.
-    """
-
-    system: NotRequired[list[SystemContentBlockTypeDef]]
-    inferenceConfig: NotRequired[InferenceConfigurationTypeDef]
-    toolConfig: NotRequired[ToolConfigurationTypeDef]
-    guardrailConfig: NotRequired[GuardrailConfigurationTypeDef]
-    additionalModelRequestFields: NotRequired[Mapping[str, Any]]
-    additionalModelResponseFieldPaths: NotRequired[list[str]]

mirascope/core/bedrock/call_response.py

@@ -1,248 +0,0 @@
-"""This module contains the `BedrockCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-from typing import cast
-
-from mypy_boto3_bedrock_runtime.type_defs import (
-    ConverseResponseTypeDef as SyncConverseResponseTypeDef,
-)
-from pydantic import SerializeAsAny, SkipValidation, computed_field
-from types_aiobotocore_bedrock_runtime.type_defs import (
-    ConverseResponseTypeDef as AsyncConverseResponseTypeDef,
-)
-
-from .. import BaseMessageParam
-from ..base import (
-    BaseCallResponse,
-    transform_tool_outputs,
-)
-from ..base.types import CostMetadata, FinishReason
-from ._call_kwargs import BedrockCallKwargs
-from ._types import (
-    AssistantMessageTypeDef,
-    AsyncMessageTypeDef,
-    InternalBedrockMessageParam,
-    SyncMessageTypeDef,
-    TokenUsageTypeDef,
-    ToolResultBlockContentTypeDef,
-    ToolResultBlockMessageTypeDef,
-    ToolTypeDef,
-    ToolUseBlockContentTypeDef,
-    UserMessageTypeDef,
-)
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-from ._utils._message_param_converter import BedrockMessageParamConverter
-from .call_params import BedrockCallParams
-from .dynamic_config import AsyncBedrockDynamicConfig, BedrockDynamicConfig
-from .tool import BedrockTool
-
-
-class BedrockCallResponse(
-    BaseCallResponse[
-        SyncConverseResponseTypeDef | AsyncConverseResponseTypeDef,
-        BedrockTool,
-        ToolTypeDef,
-        AsyncBedrockDynamicConfig | BedrockDynamicConfig,
-        InternalBedrockMessageParam,
-        BedrockCallParams,
-        UserMessageTypeDef,
-        BedrockMessageParamConverter,
-    ]
-):
-    """A convenience wrapper around the Bedrock `ChatCompletion` response.
-
-    When calling the Bedrock API using a function decorated with `bedrock_call`, the
-    response will be an `BedrockCallResponse` instance with properties that allow for
-    more convenience access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.bedrock import bedrock_call
-
-
-    @bedrock_call("anthropic.claude-3-haiku-20240307-v1:0")
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")  # response is an `BedrockCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    response: SkipValidation[SyncConverseResponseTypeDef | AsyncConverseResponseTypeDef]
-    _message_converter: type[BedrockMessageParamConverter] = (
-        BedrockMessageParamConverter
-    )
-
-    _provider = "bedrock"
-
-    @property
-    def message(self) -> SyncMessageTypeDef | AsyncMessageTypeDef | None:
-        """Returns the message of the response."""
-        message = self.response.get("output", {}).get("message", {})
-        if message:
-            return cast(SyncMessageTypeDef | AsyncMessageTypeDef, message)
-        return None
-
-    @computed_field
-    @property
-    def content(self) -> str:
-        """Returns the content of the chat completion for the 0th choice."""
-        if not self.message:
-            return ""
-        if content := self.message.get("content", []):
-            return content[0].get("text", "")
-        return ""
-
-    @computed_field
-    @property
-    def finish_reasons(self) -> list[str]:
-        """Returns the finish reasons of the response."""
-        return [self.response["stopReason"]]
-
-    @computed_field
-    @property
-    def model(self) -> str:
-        """Returns the name of the response model."""
-        return cast(BedrockCallKwargs, self.call_kwargs)["modelId"]
-
-    @computed_field
-    @property
-    def id(self) -> str:
-        """Returns the id of the response."""
-        return self.response["ResponseMetadata"]["RequestId"]
-
-    @property
-    def usage(self) -> TokenUsageTypeDef:
-        """Returns the usage of the chat completion."""
-        return self.response["usage"]
-
-    @computed_field
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        return self.usage["inputTokens"] if self.usage else None
-
-    @property
-    def cached_tokens(self) -> int | None:
-        """Returns the number of cached tokens."""
-        return None
-
-    @computed_field
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        return self.usage["outputTokens"] if self.usage else None
-
-    @computed_field
-    @cached_property
-    def message_param(self) -> SerializeAsAny[AssistantMessageTypeDef]:
-        """Returns the assistants's response as a message parameter."""
-        message = self.message
-        if not message:
-            return AssistantMessageTypeDef(role="assistant", content=[])
-        return AssistantMessageTypeDef(role="assistant", content=message["content"])
-
-    @cached_property
-    def tools(self) -> list[BedrockTool] | None:
-        """Returns any available tool calls as their `BedrockTool` definition.
-
-        Raises:
-            ValidationError: if a tool call doesn't match the tool's schema.
-            ValueError: if the model refused to response, in which case the error
-                message will be the refusal.
-        """
-        if not self.message:
-            return None
-        content = self.message.get("content", [])
-        tool_uses = [t for c in content if (t := c.get("toolUse"))]
-        if not self.tool_types or not tool_uses:
-            return None
-
-        extracted_tools = []
-        for tool_use in tool_uses:
-            for tool_type in self.tool_types:
-                if tool_use["name"] == tool_type._name():
-                    extracted_tools.append(
-                        tool_type.from_tool_call(
-                            cast(ToolUseBlockContentTypeDef, {"toolUse": tool_use})
-                        )
-                    )
-                    break
-
-        return extracted_tools
-
-    @cached_property
-    def tool(self) -> BedrockTool | None:
-        """Returns the 0th tool for the 0th choice message.
-
-        Raises:
-            ValidationError: if the tool call doesn't match the tool's schema.
-            ValueError: if the model refused to response, in which case the error
-                message will be the refusal.
-        """
-        if tools := self.tools:
-            return tools[0]
-        return None
-
-    @classmethod
-    @transform_tool_outputs
-    def tool_message_params(
-        cls, tools_and_outputs: Sequence[tuple[BedrockTool, str]]
-    ) -> list[ToolResultBlockMessageTypeDef]:
-        """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 `ChatCompletionToolMessageParam` parameters.
-        """
-        return [
-            ToolResultBlockMessageTypeDef(
-                role="user",
-                content=[
-                    cast(
-                        ToolResultBlockContentTypeDef,
-                        {
-                            "toolResult": {
-                                "content": [{"text": output}],
-                                "toolUseId": tool.tool_call["toolUse"]["toolUseId"],  # pyright: ignore [reportOptionalSubscript]
-                            }
-                        },
-                    )
-                ],
-            )
-            for tool, output in tools_and_outputs
-        ]
-
-    @property
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
-
-    @property
-    def common_message_param(self) -> BaseMessageParam:
-        return BedrockMessageParamConverter.from_provider([self.message_param])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return BedrockMessageParamConverter.from_provider([self.user_message_param])[0]  # pyright: ignore [reportArgumentType]
-
-    @computed_field
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Get metadata required for cost calculation."""
-        return super().cost_metadata

mirascope/core/bedrock/call_response_chunk.py

@@ -1,111 +0,0 @@
-"""This module contains the `BedrockCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from typing import cast
-
-from pydantic import SkipValidation
-from types_aiobotocore_bedrock_runtime.literals import StopReasonType as FinishReason
-
-from ..base import BaseCallResponseChunk, types
-from ..base.types import CostMetadata
-from ._types import AsyncStreamOutputChunk, StreamOutputChunk, TokenUsageTypeDef
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-
-
-class BedrockCallResponseChunk(
-    BaseCallResponseChunk[StreamOutputChunk | AsyncStreamOutputChunk, FinishReason]
-):
-    """A convenience wrapper around the Bedrock `ChatCompletionChunk` streamed chunks.
-
-    When calling the Bedrock API using a function decorated with `bedrock_call` and
-    `stream` set to `True`, the stream will contain `BedrockResponseChunk` instances with
-    properties that allow for more convenient access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.bedrock import bedrock_call
-
-
-    @bedrock_call("anthropic.claude-3-haiku-20240307-v1:0", stream=True)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # response is an `BedrockStream`
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    chunk: SkipValidation[StreamOutputChunk | AsyncStreamOutputChunk]
-
-    @property
-    def content(self) -> str:
-        """Returns the content for the 0th choice delta."""
-        if content_block_delta := self.chunk.get("contentBlockDelta"):
-            return content_block_delta["delta"].get("text", "")
-        return ""
-
-    @property
-    def finish_reasons(self) -> list[FinishReason]:
-        """Returns the finish reasons of the response."""
-        if (stop_reason := self.chunk.get("messageStop")) and stop_reason.get(
-            "stopReason"
-        ):
-            return [stop_reason["stopReason"]]
-        return []
-
-    @property
-    def model(self) -> str:
-        """Returns the name of the response model."""
-        return self.chunk["model"]
-
-    @property
-    def id(self) -> str:
-        """Returns the id of the response."""
-        return self.chunk["responseMetadata"]["RequestId"]
-
-    @property
-    def usage(self) -> TokenUsageTypeDef | None:
-        """Returns the usage of the chat completion."""
-        usage = self.chunk.get("metadata", {}).get("usage")
-        if usage:
-            return usage
-        return None
-
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        if self.usage:
-            return self.usage["inputTokens"]
-        return None
-
-    @property
-    def cached_tokens(self) -> int | None:
-        """Returns the number of cached tokens."""
-        return None
-
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        if self.usage:
-            return self.usage["outputTokens"]
-        return None
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Returns the cost metadata."""
-        return super().cost_metadata
-
-    @property
-    def common_finish_reasons(self) -> list[types.FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(
-            cast(list[str], self.finish_reasons)
-        )

mirascope/core/bedrock/dynamic_config.py

@@ -1,37 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from mypy_boto3_bedrock_runtime import BedrockRuntimeClient
-from types_aiobotocore_bedrock_runtime import (
-    BedrockRuntimeClient as AsyncBedrockRuntimeClient,
-)
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from ._types import InternalBedrockMessageParam
-from .call_params import BedrockCallParams
-
-AsyncBedrockDynamicConfig = BaseDynamicConfig[
-    InternalBedrockMessageParam | BaseMessageParam,
-    BedrockCallParams,
-    AsyncBedrockRuntimeClient,
-]
-BedrockDynamicConfig = BaseDynamicConfig[
-    InternalBedrockMessageParam | BaseMessageParam,
-    BedrockCallParams,
-    BedrockRuntimeClient,
-]
-
-"""The function return type for functions wrapped with the `bedrock_call` decorator.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.bedrock import BedrockDynamicConfig, bedrock_call
-
-
-@bedrock_call("anthropic.claude-3-haiku-20240307-v1:0")
-@prompt_template("Recommend a {capitalized_genre} book")
-def recommend_book(genre: str) -> BedrockDynamicConfig:
-    return {"computed_fields": {"capitalized_genre": genre.capitalize()}}
-```
-"""

mirascope/core/bedrock/stream.py

@@ -1,154 +0,0 @@
-"""The `BedrockStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from typing import Any, cast
-
-from mypy_boto3_bedrock_runtime.literals import StopReasonType as FinishReason
-from mypy_boto3_bedrock_runtime.type_defs import (
-    ConverseResponseTypeDef,
-    ConverseStreamMetadataEventTypeDef,
-    MessageOutputTypeDef,
-    ResponseMetadataTypeDef,
-)
-from types_aiobotocore_bedrock_runtime.type_defs import (
-    ConverseStreamMetadataEventTypeDef as AsyncConverseStreamMetadataEventTypeDef,
-)
-from types_aiobotocore_bedrock_runtime.type_defs import (
-    ResponseMetadataTypeDef as AsyncResponseMetadataTypeDef,
-)
-
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from ._types import (
-    AssistantMessageTypeDef,
-    InternalBedrockMessageParam,
-    ToolTypeDef,
-    ToolUseBlockContentTypeDef,
-    ToolUseBlockMessageTypeDef,
-    UserMessageTypeDef,
-)
-from .call_params import BedrockCallParams
-from .call_response import BedrockCallResponse
-from .call_response_chunk import BedrockCallResponseChunk
-from .dynamic_config import AsyncBedrockDynamicConfig, BedrockDynamicConfig
-from .tool import BedrockTool
-
-_DEFAULT_RESPONSE_METADATA = ResponseMetadataTypeDef(
-    RequestId="", HTTPStatusCode=500, HTTPHeaders={}, RetryAttempts=0
-)
-
-
-class BedrockStream(
-    BaseStream[
-        BedrockCallResponse,
-        BedrockCallResponseChunk,
-        UserMessageTypeDef,
-        AssistantMessageTypeDef,
-        ToolUseBlockMessageTypeDef,
-        InternalBedrockMessageParam,
-        BedrockTool,
-        ToolTypeDef,
-        AsyncBedrockDynamicConfig | BedrockDynamicConfig,
-        BedrockCallParams,
-        FinishReason,
-    ]
-):
-    """A class for convenience around streaming Bedrock LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.bedrock import bedrock_call
-
-
-    @bedrock_call("gpt-4o-mini", stream=True)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # returns `BedrockStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "bedrock"
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # noqa: ANN401
-        super().__init__(*args, **kwargs)
-        self._metadata: (
-            ConverseStreamMetadataEventTypeDef
-            | AsyncConverseStreamMetadataEventTypeDef
-            | None
-        ) = None
-        self._response_metadata: (
-            ResponseMetadataTypeDef | AsyncResponseMetadataTypeDef
-        ) = _DEFAULT_RESPONSE_METADATA
-
-    def _construct_message_param(
-        self,
-        tool_calls: list[ToolUseBlockContentTypeDef] | None = None,
-        content: str | None = None,
-    ) -> AssistantMessageTypeDef:
-        """Constructs the message parameter for the assistant."""
-        contents = []
-        if content is not None:
-            contents.append({"text": content})
-
-        if tool_calls:
-            contents += [
-                cast(ToolUseBlockContentTypeDef, {"toolUse": tool_call})
-                for tool_call in tool_calls
-            ]
-        message_param = AssistantMessageTypeDef(role="assistant", content=contents)
-        return message_param
-
-    def _update_properties(self, chunk: BedrockCallResponseChunk) -> None:
-        """Updates the properties of the stream."""
-        super()._update_properties(chunk)
-        if metadata := chunk.chunk.get("metadata"):
-            self._metadata = metadata
-        self._response_metadata = chunk.chunk["responseMetadata"]
-
-    def construct_call_response(self) -> BedrockCallResponse:
-        """Constructs the call response from a consumed BedrockStream.
-
-        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."
-            )
-        response = ConverseResponseTypeDef(
-            output={"message": cast(MessageOutputTypeDef, self.message_param)},
-            stopReason=self.finish_reasons[0] if self.finish_reasons else "end_turn",
-            usage=self.metadata.get("usage", {}),
-            metrics=self.metadata.get("metrics", {}),
-            additionalModelResponseFields={},
-            trace=self.metadata.get("trace", {}),
-            ResponseMetadata=self._response_metadata,
-        )
-        return BedrockCallResponse(
-            metadata=self.metadata,
-            response=response,
-            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/bedrock/tool.py

@@ -1,100 +0,0 @@
-"""The `BedrockTool` class for easy tool usage with Bedrock LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-from mypy_boto3_bedrock_runtime.type_defs import (
-    ToolSpecificationTypeDef,
-    ToolTypeDef,
-)
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool, GenerateJsonSchemaNoTitles, ToolConfig
-from ._types import ToolUseBlockContentTypeDef
-
-
-class GenerateBedrockStrictToolJsonSchema(GenerateJsonSchemaNoTitles):
-    pass
-
-
-class BedrockToolConfig(ToolConfig, total=False):
-    """A tool configuration for Bedrock-specific features."""
-
-    pass
-
-
-class BedrockTool(BaseTool):
-    """A class for defining tools for Bedrock LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.bedrock import bedrock_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @bedrock_call("anthropic.claude-3-haiku-20240307-v1:0", tools=[format_book])
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `BedrockTool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "bedrock"
-    __tool_config_type__ = BedrockToolConfig
-
-    tool_call: SkipJsonSchema[ToolUseBlockContentTypeDef]
-
-    @property
-    def id(self) -> str | None:
-        return self.tool_call["toolUse"]["toolUseId"]
-
-    @classmethod
-    def tool_schema(cls) -> ToolTypeDef:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.bedrock import BedrockTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = BedrockTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Bedrock-specific tool schema
-        ```
-        """
-        schema_generator = GenerateJsonSchemaNoTitles
-        return ToolTypeDef(
-            toolSpec=ToolSpecificationTypeDef(
-                name=cls._name(),
-                description=cls._description(),
-                inputSchema={
-                    "json": cls.model_json_schema(schema_generator=schema_generator)
-                },
-            )
-        )
-
-    @classmethod
-    def from_tool_call(cls, tool_call: ToolUseBlockContentTypeDef) -> BedrockTool:
-        """Constructs an `BedrockTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Bedrock tool call from which to construct this tool instance.
-        """
-        return cls.model_validate(
-            {"tool_call": tool_call, **tool_call["toolUse"]["input"]}
-        )