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

mirascope/core/azure/_utils/_convert_message_params.py

@@ -1,121 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ChatRequestMessage`."""
-
-import base64
-import json
-from typing import cast
-
-from azure.ai.inference.models import (
-    AssistantMessage,
-    ChatCompletionsToolCall,
-    ChatRequestMessage,
-    FunctionCall,
-    ToolMessage,
-    UserMessage,
-)
-
-from ...base import BaseMessageParam
-
-
-def convert_message_params(
-    message_params: list[BaseMessageParam | ChatRequestMessage],
-) -> list[ChatRequestMessage]:
-    converted_message_params: list[ChatRequestMessage | ToolMessage] = []
-    for message_param in message_params:
-        if not isinstance(message_param, BaseMessageParam):
-            converted_message_params.append(message_param)
-        elif isinstance((content := message_param.content), str):
-            converted_message_params.append(UserMessage(content=content))
-        else:
-            converted_content = []
-            for part in content:
-                if part.type == "text":
-                    converted_content.append(part.model_dump())
-                elif part.type == "image":
-                    if part.media_type not in [
-                        "image/jpeg",
-                        "image/png",
-                        "image/gif",
-                        "image/webp",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported image media type: {part.media_type}. Azure"
-                            " currently only supports JPEG, PNG, GIF, and WebP images."
-                        )
-                    data = base64.b64encode(part.image).decode("utf-8")
-                    converted_content.append(
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:{part.media_type};base64,{data}",
-                                "detail": part.detail if part.detail else "auto",
-                            },
-                        }
-                    )
-                elif part.type == "image_url":
-                    converted_content.append(
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": part.url,
-                                "detail": part.detail if part.detail else "auto",
-                            },
-                        }
-                    )
-                elif part.type == "tool_call":
-                    converted_message_param = AssistantMessage(
-                        tool_calls=[
-                            ChatCompletionsToolCall(
-                                id=part.id,  # pyright: ignore [reportArgumentType]
-                                function=FunctionCall(
-                                    name=part.name, arguments=json.dumps(part.args)
-                                ),
-                            )
-                        ]
-                    )
-
-                    if converted_content:
-                        if len(converted_content) == 1:
-                            if converted_content[0]["type"] == "text":
-                                converted_message_param["content"] = converted_content[
-                                    0
-                                ]["text"]
-                        else:
-                            converted_message_params.append(
-                                ChatRequestMessage(
-                                    {
-                                        "role": message_param.role,
-                                        "content": converted_content,
-                                    }
-                                )
-                            )
-                        converted_content = []
-                    converted_message_params.append(converted_message_param)
-                elif part.type == "tool_result":
-                    if converted_content:
-                        converted_message_params.append(
-                            ChatRequestMessage(
-                                {
-                                    "role": message_param.role,
-                                    "content": converted_content,
-                                }
-                            )
-                        )
-                        converted_content = []
-                    converted_message_params.append(
-                        ToolMessage(
-                            content=part.content,
-                            tool_call_id=cast(str, part.id),
-                        )
-                    )
-                else:
-                    raise ValueError(
-                        "Azure currently only supports text and image parts. "
-                        f"Part provided: {part.type}"
-                    )
-            if converted_content:
-                converted_message_params.append(
-                    ChatRequestMessage(
-                        {"role": message_param.role, "content": converted_content}
-                    )
-                )
-    return converted_message_params

mirascope/core/azure/_utils/_get_credential.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import TYPE_CHECKING
-
-from azure.core.credentials import AzureKeyCredential
-
-if TYPE_CHECKING:
-    from azure.identity import (  # pyright: ignore [reportMissingImports]
-        DefaultAzureCredential,
-    )
-else:
-    AzureDefaultCredential = None
-
-
-def _get_key_from_env() -> str | None:
-    return os.environ.get("AZURE_INFERENCE_CREDENTIAL")
-
-
-def _get_azure_default_credential() -> DefaultAzureCredential:
-    try:
-        from azure.identity import DefaultAzureCredential
-    except ImportError:
-        raise ImportError(
-            "To use the AzureDefaultCredential, please install the azure-identity package with `pip install azure-identity`."
-        )
-    return DefaultAzureCredential()
-
-
-def get_credential() -> DefaultAzureCredential | AzureKeyCredential:
-    if (credential := _get_key_from_env()) is None:
-        return _get_azure_default_credential()
-    return AzureKeyCredential(credential)

mirascope/core/azure/_utils/_get_json_output.py

@@ -1,27 +0,0 @@
-"""Get the JSON output from a completion response."""
-
-from ..call_response import AzureCallResponse
-from ..call_response_chunk import AzureCallResponseChunk
-
-
-def get_json_output(
-    response: AzureCallResponse | AzureCallResponseChunk, json_mode: bool
-) -> str:
-    """Get the JSON output from a completion response."""
-    if isinstance(response, AzureCallResponse):
-        if json_mode and response.content:
-            return response.content
-        elif tool_calls := response.response.choices[0].message.tool_calls:
-            return tool_calls[0].function.arguments
-        raise ValueError("No tool call or JSON object found in response.")
-    else:
-        if json_mode:
-            return response.content
-        elif (
-            (choices := response.chunk.choices)
-            and (tool_calls := choices[0].delta.tool_calls)
-            and (function := tool_calls[0].function)
-            and (arguments := function.arguments) is not None
-        ):
-            return arguments
-        return ""

mirascope/core/azure/_utils/_handle_stream.py

@@ -1,130 +0,0 @@
-"""Handles the stream of completion chunks."""
-
-import copy
-from collections.abc import AsyncGenerator, Generator
-
-from azure.ai.inference.models import (
-    ChatCompletionsToolCall,
-    FunctionCall,
-    StreamingChatCompletionsUpdate,
-)
-
-from ..call_response_chunk import AzureCallResponseChunk
-from ..tool import AzureTool
-
-
-def _handle_chunk(
-    chunk: StreamingChatCompletionsUpdate,
-    current_tool_call: ChatCompletionsToolCall,
-    current_tool_type: type[AzureTool] | None,
-    tool_types: list[type[AzureTool]] | None,
-) -> tuple[
-    AzureTool | None,
-    ChatCompletionsToolCall,
-    type[AzureTool] | None,
-]:
-    """Handles a chunk of the stream."""
-    if (
-        not tool_types
-        or not chunk.choices
-        or not (tool_calls := chunk.choices[0].delta.tool_calls)
-    ):
-        return None, current_tool_call, current_tool_type
-
-    tool_call = tool_calls[0]
-    # Reset on new tool
-    if tool_call.id and tool_call.function is not None:
-        previous_tool_call = copy.deepcopy(current_tool_call)
-        previous_tool_type = current_tool_type
-        current_tool_call = ChatCompletionsToolCall(
-            id=tool_call.id,
-            function=FunctionCall(
-                arguments="",
-                name=tool_call.function.name if tool_call.function.name else "",
-            ),
-        )
-        current_tool_type = None
-        for tool_type in tool_types:
-            if tool_type._name() == tool_call.function.name:
-                current_tool_type = tool_type
-                break
-        if current_tool_type is None:
-            raise RuntimeError(
-                f"Unknown tool type in stream: {tool_call.function.name}"
-            )  # pragma: no cover
-        if (
-            previous_tool_call.id
-            and previous_tool_call.function.arguments
-            and previous_tool_type is not None
-        ):
-            return (
-                previous_tool_type.from_tool_call(previous_tool_call),
-                current_tool_call,
-                current_tool_type,
-            )
-
-    # Update arguments with each chunk
-    if tool_call.function and tool_call.function.arguments:
-        current_tool_call.function.arguments += tool_call.function.arguments
-
-    return None, current_tool_call, current_tool_type
-
-
-def handle_stream(
-    stream: Generator[StreamingChatCompletionsUpdate, None, None],
-    tool_types: list[type[AzureTool]] | None,
-    partial_tools: bool = False,
-) -> Generator[tuple[AzureCallResponseChunk, AzureTool | None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ChatCompletionsToolCall(
-        id="", function=FunctionCall(arguments="", name="")
-    )
-    current_tool_type = None
-    for chunk in stream:
-        if not tool_types or not chunk.choices or not chunk.choices[0].delta.tool_calls:
-            if current_tool_type:
-                yield (
-                    AzureCallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield AzureCallResponseChunk(chunk=chunk), None
-        tool, current_tool_call, current_tool_type = _handle_chunk(
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-        )
-        if tool is not None:
-            yield AzureCallResponseChunk(chunk=chunk), tool
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[StreamingChatCompletionsUpdate, None],
-    tool_types: list[type[AzureTool]] | None,
-    partial_tools: bool = False,
-) -> AsyncGenerator[tuple[AzureCallResponseChunk, AzureTool | None], None]:
-    """Async iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ChatCompletionsToolCall(
-        id="", function=FunctionCall(arguments="", name="")
-    )
-    current_tool_type = None
-    async for chunk in stream:
-        if not tool_types or not chunk.choices[0].delta.tool_calls:
-            if current_tool_type:
-                yield (
-                    AzureCallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield AzureCallResponseChunk(chunk=chunk), None
-        tool, current_tool_call, current_tool_type = _handle_chunk(
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-        )
-        if tool is not None:
-            yield AzureCallResponseChunk(chunk=chunk), tool

mirascope/core/azure/_utils/_message_param_converter.py

@@ -1,117 +0,0 @@
-import json
-from typing import cast
-
-from azure.ai.inference.models import (
-    AssistantMessage,
-    ChatRequestMessage,
-    ContentItem,
-    ImageContentItem,
-    TextContentItem,
-    ToolMessage,
-    UserMessage,
-)
-
-from mirascope.core.azure._utils import convert_message_params
-from mirascope.core.base import (
-    BaseMessageParam,
-    ImageURLPart,
-    TextPart,
-    ToolCallPart,
-    ToolResultPart,
-)
-from mirascope.core.base._utils._base_message_param_converter import (
-    BaseMessageParamConverter,
-)
-
-
-def _parse_content(content: list[ContentItem]) -> list[TextPart | ImageURLPart]:
-    converted_parts = []
-    for part in content:
-        if isinstance(part, TextContentItem):
-            converted_parts.append(TextPart(type="text", text=part.text))
-        elif isinstance(part, ImageContentItem):
-            converted_parts.append(
-                ImageURLPart(
-                    type="image_url",
-                    url=part.image_url.url,
-                    detail=part.image_url.detail,
-                )
-            )
-
-    return converted_parts
-
-
-class AzureMessageParamConverter(BaseMessageParamConverter):
-    """Converts between Azure `ChatRequestMessage` / `AssistantMessage` and Mirascope `BaseMessageParam`."""
-
-    @staticmethod
-    def to_provider(message_params: list[BaseMessageParam]) -> list[ChatRequestMessage]:
-        """Convert from Mirascope `BaseMessageParam` to Azure's `ChatRequestMessage`."""
-        return convert_message_params(
-            cast(list[BaseMessageParam | ChatRequestMessage], message_params)
-        )
-
-    @staticmethod
-    def from_provider(
-        message_params: list[ChatRequestMessage],
-    ) -> list[BaseMessageParam]:
-        """
-        Convert from Azure's `AssistantMessage` back to Mirascope `BaseMessageParam`.
-        """
-        converted: list[BaseMessageParam] = []
-        for message_param in message_params:
-            if isinstance(message_param, UserMessage):
-                if isinstance(message_param.content, str):
-                    converted.append(
-                        BaseMessageParam(role="user", content=message_param.content)
-                    )
-                elif isinstance(message_param.content, list):
-                    converted_parts = _parse_content(message_param.content)
-                    converted.append(
-                        BaseMessageParam(role="user", content=converted_parts)
-                    )
-            elif isinstance(message_param, AssistantMessage):
-                converted_parts = []
-                if tool_calls := message_param.tool_calls:
-                    converted_parts.extend(
-                        ToolCallPart(
-                            type="tool_call",
-                            name=tool_call.function.name,
-                            id=tool_call.id,
-                            args=json.loads(tool_call.function.arguments),
-                        )
-                        for tool_call in tool_calls
-                    )
-                if isinstance(message_param.content, str):
-                    converted_parts.append(
-                        TextPart(type="text", text=message_param.content)
-                    )
-                elif isinstance(message_param.content, list):
-                    converted_parts = _parse_content(message_param.content)
-                else:
-                    converted_parts.append(TextPart(type="text", text=""))
-                converted.append(
-                    BaseMessageParam(
-                        role="assistant",
-                        content=converted_parts[0].text
-                        if len(converted_parts) == 1
-                        and isinstance(converted_parts[0], TextPart)
-                        else converted_parts,
-                    )
-                )
-            elif isinstance(message_param, ToolMessage):
-                converted.append(
-                    BaseMessageParam(
-                        role="tool",
-                        content=[
-                            ToolResultPart(
-                                type="tool_result",
-                                name="",
-                                content=message_param.content,
-                                id=message_param.tool_call_id,
-                                is_error=False,
-                            )
-                        ],
-                    )
-                )
-        return converted

mirascope/core/azure/_utils/_setup_call.py

@@ -1,183 +0,0 @@
-"""This module contains the setup_call function for Azure tools."""
-
-import inspect
-import os
-import warnings
-from collections.abc import AsyncIterable, Awaitable, Callable, Iterable
-from typing import Any, cast, overload
-
-from azure.ai.inference import ChatCompletionsClient
-from azure.ai.inference.aio import ChatCompletionsClient as AsyncChatCompletionsClient
-from azure.ai.inference.models import (
-    ChatCompletions,
-    ChatRequestMessage,
-    StreamingChatCompletionsUpdate,
-    UserMessage,
-)
-from azure.core.credentials import AzureKeyCredential
-from pydantic import BaseModel
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ...base._utils import (
-    DEFAULT_TOOL_DOCSTRING,
-    AsyncCreateFn,
-    CreateFn,
-    get_async_create_fn,
-    get_create_fn,
-)
-from ...base.call_params import CommonCallParams
-from ...base.stream_config import StreamConfig
-from .._call_kwargs import AzureCallKwargs
-from ..call_params import AzureCallParams, ResponseFormatJSON
-from ..dynamic_config import AsyncAzureDynamicConfig, AzureDynamicConfig
-from ..tool import AzureTool, GenerateAzureStrictToolJsonSchema
-from ._convert_common_call_params import convert_common_call_params
-from ._convert_message_params import convert_message_params
-from ._get_credential import get_credential
-
-try:
-    from azure.ai.inference.models._models import (
-        ChatCompletionsResponseFormatJSON as FormatJSON,
-    )
-
-    json_object: ResponseFormatJSON | None = None
-except ImportError:  # pragma: no cover
-    # https://github.com/Azure/azure-sdk-for-python/commit/cf61ada8243d619ee6164bf1d32b3939b3c271e5#diff-0fb29d8cce6df3a014592ba8e9959409b8c471088381549807239324f5e8ddc4R15-R17
-    from azure.ai.inference.models._models import (
-        JsonSchemaFormat as FormatJSON,  # pyright: ignore [reportAttributeAccessIssue]
-    )
-
-    json_object = "json_object"  # pyright: ignore [reportAssignmentType]
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: AsyncChatCompletionsClient | None,
-    fn: Callable[..., Awaitable[AsyncAzureDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: AsyncAzureDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: AzureCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[ChatCompletions, StreamingChatCompletionsUpdate],
-    str | None,
-    list[ChatRequestMessage],
-    list[type[AzureTool]] | None,
-    AzureCallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: ChatCompletionsClient | None,
-    fn: Callable[..., AzureDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: AzureDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: AzureCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletions, StreamingChatCompletionsUpdate],
-    str | None,
-    list[ChatRequestMessage],
-    list[type[AzureTool]] | None,
-    AzureCallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: ChatCompletionsClient | AsyncChatCompletionsClient | None,
-    fn: Callable[..., AzureDynamicConfig]
-    | Callable[..., Awaitable[AzureDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: AzureDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: AzureCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletions, StreamingChatCompletionsUpdate]
-    | AsyncCreateFn[ChatCompletions, StreamingChatCompletionsUpdate],
-    str | None,
-    list[ChatRequestMessage],
-    list[type[AzureTool]] | None,
-    AzureCallKwargs,
-]:
-    prompt_template, messages, tool_types, base_call_kwargs = _utils.setup_call(
-        fn,
-        fn_args,
-        dynamic_config,
-        tools,
-        AzureTool,
-        call_params,
-        convert_common_call_params,
-    )
-    call_kwargs = cast(AzureCallKwargs, base_call_kwargs)
-    messages = cast(list[BaseMessageParam | ChatRequestMessage], messages)
-    messages = convert_message_params(messages)
-    if json_mode:
-        if response_model and response_model.model_config.get("strict", False):
-            call_kwargs["response_format"] = FormatJSON(
-                {
-                    "name": response_model.__name__,
-                    "description": response_model.__doc__ or DEFAULT_TOOL_DOCSTRING,
-                    "strict": True,
-                    "schema": response_model.model_json_schema(
-                        schema_generator=GenerateAzureStrictToolJsonSchema
-                    ),
-                }
-            )
-        else:
-            call_kwargs["response_format"] = json_object or FormatJSON()
-            json_mode_content = _utils.json_mode_content(response_model).strip()
-            messages.append(UserMessage(content=json_mode_content))
-    elif response_model:
-        assert tool_types, "At least one tool must be provided for extraction."
-        if tool_types and tool_types[0].model_config.get("strict", False):
-            warnings.warn(
-                "You must set `json_mode=True` to use `strict=True` response models. "
-                "Ignoring `strict` and using tools for extraction.",
-                UserWarning,
-            )
-        call_kwargs["tool_choice"] = "required"
-    call_kwargs |= {"model": model, "messages": messages}
-
-    if client is None:
-        endpoint = os.environ["AZURE_INFERENCE_ENDPOINT"]
-        credential = cast(AzureKeyCredential, get_credential())
-
-        client = (
-            AsyncChatCompletionsClient(endpoint=endpoint, credential=credential)
-            if inspect.iscoroutinefunction(fn)
-            else ChatCompletionsClient(endpoint=endpoint, credential=credential)
-        )
-    create = (
-        get_async_create_fn(
-            cast(
-                AsyncCreateFn[
-                    ChatCompletions, AsyncIterable[StreamingChatCompletionsUpdate]
-                ],
-                client.complete,
-            )
-        )
-        if isinstance(client, AsyncChatCompletionsClient)
-        else get_create_fn(
-            cast(
-                CreateFn[ChatCompletions, Iterable[StreamingChatCompletionsUpdate]],
-                client.complete,
-            )
-        )
-    )
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/azure/call_params.py

@@ -1,59 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from typing import Any, Literal, TypeAlias
-
-from azure.ai.inference.models import (
-    ChatCompletionsNamedToolChoice,
-    ChatCompletionsToolChoicePreset,
-)
-
-try:
-    from azure.ai.inference.models import (
-        ChatCompletionsResponseFormatJSON,
-    )
-
-    ResponseFormatJSON: TypeAlias = ChatCompletionsResponseFormatJSON  # pyright: ignore [reportRedeclaration]
-except ImportError:  # pragma: no cover
-    from azure.ai.inference.models import (
-        JsonSchemaFormat,  # pyright: ignore [reportAttributeAccessIssue]
-    )
-
-    ResponseFormatJSON: TypeAlias = JsonSchemaFormat | Literal["json_object"]  # pyright: ignore [reportRedeclaration]
-
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-
-class AzureCallParams(BaseCallParams):
-    """The parameters to use when calling the Azure API.
-
-    [Azure API Reference](https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/ai/azure-ai-inference)
-
-    Attributes:
-        frequency_penalty: ...
-        max_tokens: ...
-        model_extras: ...
-        presence_penalty: ...
-        response_format: ...
-        seed: ...
-        stop: ...
-        temperature: ...
-        tool_choice: ...
-        top_p: ...
-    """
-
-    frequency_penalty: NotRequired[float | None]
-    max_tokens: NotRequired[int | None]
-    model_extras: NotRequired[dict[str, Any] | None]
-    presence_penalty: NotRequired[float | None]
-    response_format: NotRequired[ResponseFormatJSON | None]
-    seed: NotRequired[int | None]
-    stop: NotRequired[list[str] | None]
-    temperature: NotRequired[float | None]
-    tool_choice: NotRequired[
-        str | ChatCompletionsToolChoicePreset | ChatCompletionsNamedToolChoice | None
-    ]
-    top_p: NotRequired[float | None]