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

mirascope/core/base/types.py

@@ -1,344 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Annotated, Literal, TypeAlias
-
-from pydantic import BaseModel, ConfigDict, Field
-
-if TYPE_CHECKING:
-    from PIL import Image
-    from pydub import AudioSegment
-
-    has_pil_module: bool
-    has_pydub_module: bool
-else:
-    try:
-        from PIL import Image  # pyright: ignore [reportAssignmentType]
-
-        has_pil_module = True
-    except ImportError:  # pragma: no cover
-        has_pil_module = False
-
-        class Image:
-            class Image:
-                def tobytes(self) -> bytes: ...
-
-    try:
-        from pydub import AudioSegment  # pyright: ignore [reportAssignmentType]
-
-        has_pydub_module = True
-    except ImportError:  # pragma: no cover
-        has_pydub_module = False
-
-        from io import FileIO
-
-        class AudioSegment:
-            def set_frame_rate(self, rate: int) -> AudioSegment: ...
-            def set_channels(self, channels: int) -> AudioSegment: ...
-            def set_sample_width(self, sample_width: int) -> AudioSegment: ...
-            def export(self, format: str) -> FileIO: ...
-            def read(self) -> bytes: ...
-
-
-FinishReason: TypeAlias = Literal["stop", "length", "tool_calls", "content_filter"]
-
-
-class Usage(BaseModel):
-    input_tokens: int
-    """Number of tokens in the prompt."""
-
-    cached_tokens: int
-    """Number of tokens used that were previously cached (and thus cheaper)."""
-
-    output_tokens: int
-    """Number of tokens in the generated output."""
-
-    total_tokens: int
-    """Total number of tokens used in the request (prompt + completion)."""
-
-
-JsonableType: TypeAlias = (
-    str
-    | int
-    | float
-    | bool
-    | bytes
-    | list["JsonableType"]
-    | set["JsonableType"]
-    | tuple["JsonableType", ...]
-    | dict[str, "JsonableType"]
-    | BaseModel
-)
-
-
-class VideoMetadata(BaseModel):
-    """Metadata for a video for cost calculation"""
-
-    duration_seconds: Annotated[
-        float,
-        Field(description="Duration of the video in seconds"),
-    ]
-
-    with_audio: Annotated[
-        bool | None,
-        Field(
-            default=False,
-            description="Whether the video includes audio that should be processed",
-        ),
-    ] = False
-
-    tokens: Annotated[
-        int | None,
-        Field(default=None, description="Precalculated token count for this video"),
-    ] = None
-
-
-class AudioMetadata(BaseModel):
-    """Metadata for an audio file for cost calculation"""
-
-    duration_seconds: Annotated[
-        float,
-        Field(description="Duration of the audio in seconds"),
-    ]
-
-    with_timestamps: Annotated[
-        bool | None,
-        Field(default=False, description="Whether timestamps should be included"),
-    ] = False
-
-    tokens: Annotated[
-        int | None,
-        Field(default=None, description="Precalculated token count for this audio"),
-    ] = None
-
-
-class ImageMetadata(BaseModel):
-    """Metadata for an image for cost calculation"""
-
-    width: Annotated[
-        int,
-        Field(description="Width of the image in pixels"),
-    ]
-
-    height: Annotated[
-        int,
-        Field(description="Height of the image in pixels"),
-    ]
-
-    tokens: Annotated[
-        int | None,
-        Field(default=None, description="Precalculated token count for this image"),
-    ] = None
-
-    detail: Annotated[
-        str | None,
-        Field(default=None, description="Detail level of the image"),
-    ] = None
-
-
-class GoogleMetadata(BaseModel):
-    """Google API specific metadata for cost calculation"""
-
-    use_vertex_ai: Annotated[
-        bool | None,
-        Field(
-            default=False,
-            description="Whether to use Vertex AI pricing (vs. direct Gemini API)",
-        ),
-    ] = False
-
-    grounding_requests: Annotated[
-        int | None,
-        Field(default=None, description="Number of Google Search grounding requests"),
-    ] = None
-
-
-class PDFImageMetadata(BaseModel):
-    """Metadata for an image extracted from a PDF page"""
-
-    width: Annotated[
-        int,
-        Field(description="Width of the image in pixels"),
-    ]
-
-    height: Annotated[
-        int,
-        Field(description="Height of the image in pixels"),
-    ]
-
-    tokens: Annotated[
-        int | None,
-        Field(default=None, description="Precalculated token count for this image"),
-    ] = None
-
-
-class PDFMetadata(BaseModel):
-    """Metadata specific to PDF documents for cost calculation"""
-
-    page_count: Annotated[
-        int | None,
-        Field(default=None, description="Number of pages in the PDF"),
-    ] = None
-
-    text_tokens: Annotated[
-        int | None,
-        Field(
-            default=None, description="Number of tokens from text content in the PDF"
-        ),
-    ] = None
-
-    images: Annotated[
-        list[PDFImageMetadata] | None,
-        Field(
-            default=None,
-            description="List of images extracted from PDF with width and height information",
-        ),
-    ] = None
-
-    cached: Annotated[
-        bool | None,
-        Field(
-            default=None,
-            description="Whether this PDF was cached for reduced token costs",
-        ),
-    ] = None
-
-
-class CostMetadata(BaseModel):
-    """Metadata required for accurate LLM API cost calculation across all providers."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    # Common fields
-    input_tokens: Annotated[
-        int | float | None,
-        Field(default=None, description="Input tokens"),
-    ] = None
-    output_tokens: Annotated[
-        int | float | None,
-        Field(default=None, description="Output tokens"),
-    ] = None
-    cached_tokens: Annotated[
-        int | float | None,
-        Field(default=None, description="Cached tokens"),
-    ] = None
-    streaming_mode: Annotated[
-        bool | None,
-        Field(default=None, description="Whether streaming API was used"),
-    ] = None
-    cached_response: Annotated[
-        bool | None,
-        Field(default=None, description="Whether response was served from cache"),
-    ] = None
-    context_length: Annotated[
-        int | None,
-        Field(default=None, description="Total context window length in tokens"),
-    ] = None
-    realtime_mode: Annotated[
-        bool | None,
-        Field(default=None, description="Whether realtime processing was used"),
-    ] = None
-    region: Annotated[
-        str | None,
-        Field(
-            default=None,
-            description="Cloud region for request (affects pricing in some providers)",
-        ),
-    ] = None
-    tier: Annotated[
-        str | None,
-        Field(default=None, description="Service tier (e.g. standard, enterprise)"),
-    ] = None
-    batch_mode: Annotated[
-        bool | None,
-        Field(
-            default=False,
-            description="Whether batch mode is used (discount usually applies)",
-        ),
-    ] = None
-
-    # Media-related fields
-    images: Annotated[
-        list[ImageMetadata] | None,
-        Field(default=None, description="List of images with their metadata"),
-    ] = None
-    videos: Annotated[
-        list[VideoMetadata] | None,
-        Field(default=None, description="List of videos with their metadata"),
-    ] = None
-    audio: Annotated[
-        list[AudioMetadata] | None,
-        Field(default=None, description="List of audio clips with their metadata"),
-    ] = None
-    audio_output: Annotated[
-        list[AudioMetadata] | None,
-        Field(
-            default=None, description="List of audio output clips with their metadata"
-        ),
-    ] = None
-    # PDF-related fields
-    pdf: Annotated[
-        PDFMetadata | None,
-        Field(default=None, description="Metadata for PDF documents"),
-    ] = None
-
-    # Context caching related fields
-    context_cache_tokens: Annotated[
-        int | None,
-        Field(default=None, description="Number of cached context tokens"),
-    ] = None
-    context_cache_hours: Annotated[
-        float | None,
-        Field(default=None, description="Number of hours to keep context in cache"),
-    ] = None
-
-    # Provider-specific fields
-    google: Annotated[
-        GoogleMetadata | None,
-        Field(
-            default=None,
-            description="Google/Gemini-specific metadata for cost calculation",
-        ),
-    ] = None
-    realtime_tokens: Annotated[
-        int | None,
-        Field(
-            default=None,
-            description="[OpenAI] Number of realtime tokens in the request",
-        ),
-    ] = None
-
-    # Anthropic-specific fields
-    cache_write: Annotated[
-        bool | None,
-        Field(default=None, description="[Anthropic] Whether cache write occurred"),
-    ] = None
-    tool_use_tokens: Annotated[
-        int | None,
-        Field(default=None, description="[Anthropic] Tokens used for tool calls"),
-    ] = None
-
-    # If the provider happens to provide the cost, we should just use that.
-    cost: Annotated[
-        float | None,
-        Field(default=None, description="Cost provided by the API response"),
-    ] = None
-
-
-Provider: TypeAlias = Literal[
-    "anthropic",
-    "azure",
-    "bedrock",
-    "cohere",
-    "gemini",
-    "google",
-    "groq",
-    "litellm",
-    "mistral",
-    "openai",
-    "vertex",
-    "xai",
-]
-LocalProvider: TypeAlias = Literal[
-    "ollama",
-    "vllm",
-]

mirascope/core/bedrock/__init__.py

@@ -1,34 +0,0 @@
-from typing import TypeAlias
-
-from .. import BaseMessageParam
-from ._call import bedrock_call
-from ._call import bedrock_call as call
-from ._types import (
-    AssistantMessageTypeDef,
-    InternalBedrockMessageParam,
-    UserMessageTypeDef,
-)
-from .call_params import BedrockCallParams
-from .call_response import BedrockCallResponse
-from .call_response_chunk import BedrockCallResponseChunk
-from .dynamic_config import AsyncBedrockDynamicConfig, BedrockDynamicConfig
-from .stream import BedrockStream
-from .tool import BedrockTool, BedrockToolConfig
-
-BedrockMessageParam: TypeAlias = InternalBedrockMessageParam | BaseMessageParam
-
-__all__ = [
-    "AssistantMessageTypeDef",
-    "AsyncBedrockDynamicConfig",
-    "BedrockCallParams",
-    "BedrockCallResponse",
-    "BedrockCallResponseChunk",
-    "BedrockDynamicConfig",
-    "BedrockMessageParam",
-    "BedrockStream",
-    "BedrockTool",
-    "BedrockToolConfig",
-    "UserMessageTypeDef",
-    "bedrock_call",
-    "call",
-]

mirascope/core/bedrock/_call.py

@@ -1,68 +0,0 @@
-"""The `bedrock_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 BedrockCallParams
-from .call_response import BedrockCallResponse
-from .call_response_chunk import BedrockCallResponseChunk
-from .stream import BedrockStream
-from .tool import BedrockTool
-
-bedrock_call = call_factory(
-    TCallResponse=BedrockCallResponse,
-    TCallResponseChunk=BedrockCallResponseChunk,
-    TToolType=BedrockTool,
-    TStream=BedrockStream,
-    default_call_params=BedrockCallParams(),
-    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 Bedrock API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Bedrock 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.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")
-print(response.content)
-```
-
-Args:
-    model (str): The Bedrock 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 Bedrock API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[BedrockCallResponse | 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 (BedrockCallParams): The `BedrockCallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into an Bedrock API
-        call.
-"""

mirascope/core/bedrock/_call_kwargs.py

@@ -1,12 +0,0 @@
-"""This module contains the type definition for the Bedrock call keyword arguments."""
-
-from collections.abc import Sequence
-
-from ..base import BaseCallKwargs
-from ._types import InternalBedrockMessageParam, ToolTypeDef
-from .call_params import BedrockCallParams
-
-
-class BedrockCallKwargs(BedrockCallParams, BaseCallKwargs[ToolTypeDef]):
-    modelId: str
-    messages: Sequence[InternalBedrockMessageParam]

mirascope/core/bedrock/_types.py

@@ -1,104 +0,0 @@
-from typing import Literal, TypeAlias
-
-from mypy_boto3_bedrock_runtime.literals import (
-    ConversationRoleType as SyncConversationRoleType,
-)
-from mypy_boto3_bedrock_runtime.type_defs import (
-    ContentBlockOutputTypeDef as SyncContentBlockOutputTypeDef,
-)
-from mypy_boto3_bedrock_runtime.type_defs import (
-    ConverseStreamOutputTypeDef,
-    ResponseMetadataTypeDef,
-    ToolResultBlockOutputTypeDef,
-    ToolUseBlockOutputTypeDef,
-)
-from mypy_boto3_bedrock_runtime.type_defs import (
-    TokenUsageTypeDef as SyncTokenUsageTypeDef,
-)
-from mypy_boto3_bedrock_runtime.type_defs import (
-    ToolTypeDef as SyncToolTypeDef,
-)
-from types_aiobotocore_bedrock_runtime.literals import (
-    ConversationRoleType as AsyncConversationRoleType,
-)
-from types_aiobotocore_bedrock_runtime.type_defs import (
-    ContentBlockOutputTypeDef as AsyncContentBlockOutputTypeDef,
-)
-from types_aiobotocore_bedrock_runtime.type_defs import (
-    ConverseStreamOutputTypeDef as AsyncConverseStreamOutputTypeDef,
-)
-from types_aiobotocore_bedrock_runtime.type_defs import (
-    ResponseMetadataTypeDef as AsyncResponseMetadataTypeDef,
-)
-from types_aiobotocore_bedrock_runtime.type_defs import (
-    TokenUsageTypeDef as AsyncTokenUsageTypeDef,
-)
-from types_aiobotocore_bedrock_runtime.type_defs import (
-    ToolTypeDef as AsyncToolTypeDef,
-)
-from types_aiobotocore_bedrock_runtime.type_defs import (
-    ToolUseBlockOutputTypeDef as AsyncToolUseBlockOutputTypeDef,
-)
-from typing_extensions import TypedDict
-
-TokenUsageTypeDef: TypeAlias = SyncTokenUsageTypeDef | AsyncTokenUsageTypeDef
-ConversationRoleType: TypeAlias = SyncConversationRoleType | AsyncConversationRoleType
-ContentBlockOutputTypeDef: TypeAlias = (
-    SyncContentBlockOutputTypeDef | AsyncContentBlockOutputTypeDef
-)
-ToolTypeDef: TypeAlias = SyncToolTypeDef | AsyncToolTypeDef
-
-
-class ToolUseBlockContentTypeDef(TypedDict):
-    toolUse: ToolUseBlockOutputTypeDef | AsyncToolUseBlockOutputTypeDef
-
-
-class ToolUseBlockMessageTypeDef(TypedDict):
-    role: ConversationRoleType
-    content: list[ToolUseBlockContentTypeDef]
-
-
-class ToolResultBlockContentTypeDef(TypedDict):
-    toolResult: ToolResultBlockOutputTypeDef
-
-
-class ToolResultBlockMessageTypeDef(TypedDict):
-    role: ConversationRoleType
-    content: list[ToolResultBlockContentTypeDef]
-
-
-class AsyncMessageTypeDef(TypedDict):
-    role: AsyncConversationRoleType
-    content: list[AsyncContentBlockOutputTypeDef]
-
-
-class SyncMessageTypeDef(TypedDict):
-    role: SyncConversationRoleType
-    content: list[SyncContentBlockOutputTypeDef]
-
-
-MessageTypeDef: TypeAlias = SyncMessageTypeDef | AsyncMessageTypeDef
-
-InternalBedrockMessageParam: TypeAlias = (
-    MessageTypeDef | ToolResultBlockMessageTypeDef | ToolUseBlockMessageTypeDef
-)
-
-
-class UserMessageTypeDef(TypedDict):
-    role: Literal["user"]
-    content: list[SyncContentBlockOutputTypeDef]
-
-
-class AssistantMessageTypeDef(TypedDict):
-    role: ConversationRoleType
-    content: list[SyncContentBlockOutputTypeDef]
-
-
-class StreamOutputChunk(ConverseStreamOutputTypeDef):
-    responseMetadata: ResponseMetadataTypeDef
-    model: str
-
-
-class AsyncStreamOutputChunk(AsyncConverseStreamOutputTypeDef):
-    responseMetadata: AsyncResponseMetadataTypeDef
-    model: str

mirascope/core/bedrock/_utils/__init__.py

@@ -1,14 +0,0 @@
-"""Bedrock 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/bedrock/_utils/_convert_common_call_params.py

@@ -1,39 +0,0 @@
-from typing import cast
-
-from mypy_boto3_bedrock_runtime.type_defs import (
-    InferenceConfigurationTypeDef,
-)
-
-from ...base.call_params import CommonCallParams
-from ..call_params import BedrockCallParams
-
-BEDROCK_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "maxTokens",
-    "top_p": "topP",
-    "stop": "stopSequences",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> BedrockCallParams:
-    """Convert CommonCallParams to Bedrock parameters."""
-    inference_config = {}
-
-    for key, value in common_params.items():
-        if key not in BEDROCK_PARAM_MAPPING or value is None:
-            continue
-
-        if key == "stop":
-            inference_config["stopSequences"] = (
-                [value] if isinstance(value, str) else value
-            )
-        else:
-            inference_config[BEDROCK_PARAM_MAPPING[key]] = value
-
-    if not inference_config:
-        return cast(BedrockCallParams, {})
-
-    return cast(
-        BedrockCallParams,
-        {"inferenceConfig": cast(InferenceConfigurationTypeDef, inference_config)},
-    )

mirascope/core/bedrock/_utils/_convert_finish_reason_to_common_finish_reasons.py

@@ -1,23 +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] = {
-    "content_filtered": "content_filter",
-    "end_turn": "stop",
-    "guardrail_intervened": "content_filter",
-    "max_tokens": "length",
-    "stop_sequence": "stop",
-    "tool_use": "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
-    )