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

mirascope/core/openai/_utils/_handle_stream.py

@@ -1,138 +0,0 @@
-"""Handles the stream of completion chunks."""
-
-from collections.abc import AsyncGenerator, Generator
-from typing import cast
-
-from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageToolCall
-from openai.types.chat.chat_completion_message_tool_call import Function
-
-from ..call_response_chunk import OpenAICallResponseChunk
-from ..tool import OpenAITool
-
-
-def _handle_chunk(
-    chunk: ChatCompletionChunk,
-    current_tool_call: ChatCompletionMessageToolCall,
-    current_tool_type: type[OpenAITool] | None,
-    tool_types: list[type[OpenAITool]] | None,
-    partial_tools: bool = False,
-) -> tuple[
-    OpenAITool | None,
-    ChatCompletionMessageToolCall,
-    type[OpenAITool] | 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 = current_tool_call.model_copy()
-        previous_tool_type = current_tool_type
-        current_tool_call = ChatCompletionMessageToolCall(
-            id=tool_call.id,
-            function=Function(
-                arguments="",
-                name=tool_call.function.name if tool_call.function.name else "",
-            ),
-            type="function",
-        )
-        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 partial tool state if enabled
-        if partial_tools and current_tool_type:
-            partial_tool = current_tool_type.from_tool_call(current_tool_call, True)
-            # Set delta to current chunk arguments
-            partial_tool.delta = cast(str, tool_call.function.arguments)
-            return partial_tool, current_tool_call, current_tool_type
-
-    return None, current_tool_call, current_tool_type
-
-
-def handle_stream(
-    stream: Generator[ChatCompletionChunk, None, None],
-    tool_types: list[type[OpenAITool]] | None,
-    partial_tools: bool = False,
-) -> Generator[tuple[OpenAICallResponseChunk, OpenAITool | None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ChatCompletionMessageToolCall(
-        id="", function=Function(arguments="", name=""), type="function"
-    )
-    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 (
-                    OpenAICallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield OpenAICallResponseChunk(chunk=chunk), None
-        tool, current_tool_call, current_tool_type = _handle_chunk(
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-            partial_tools,
-        )
-        if tool is not None:
-            yield OpenAICallResponseChunk(chunk=chunk), tool
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[ChatCompletionChunk, None],
-    tool_types: list[type[OpenAITool]] | None,
-    partial_tools: bool = False,
-) -> AsyncGenerator[tuple[OpenAICallResponseChunk, OpenAITool | None], None]:
-    """Async iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ChatCompletionMessageToolCall(
-        id="", function=Function(arguments="", name=""), type="function"
-    )
-    current_tool_type = None
-    async 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 (
-                    OpenAICallResponseChunk(chunk=chunk),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield OpenAICallResponseChunk(chunk=chunk), None
-        tool, current_tool_call, current_tool_type = _handle_chunk(
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-            partial_tools,
-        )
-        if tool is not None:
-            yield OpenAICallResponseChunk(chunk=chunk), tool

mirascope/core/openai/_utils/_message_param_converter.py

@@ -1,105 +0,0 @@
-"""This module contains the OpenAIMessageParamConverter class."""
-
-import json
-from collections.abc import Iterable
-from typing import cast
-
-from openai.types.chat import ChatCompletionMessageParam
-
-from mirascope.core import BaseMessageParam
-from mirascope.core.base import (
-    AudioPart,
-    ImageURLPart,
-    TextPart,
-    ToolCallPart,
-    ToolResultPart,
-)
-from mirascope.core.base._utils._base_message_param_converter import (
-    BaseMessageParamConverter,
-)
-from mirascope.core.openai._utils import convert_message_params
-
-
-class OpenAIMessageParamConverter(BaseMessageParamConverter):
-    @staticmethod
-    def to_provider(
-        message_params: list[BaseMessageParam],
-    ) -> list[ChatCompletionMessageParam]:
-        """Converts base message params to OpenAI message params."""
-        return convert_message_params(
-            cast(list[BaseMessageParam | ChatCompletionMessageParam], message_params)
-        )
-
-    @staticmethod
-    def from_provider(
-        message_params: list[ChatCompletionMessageParam],
-    ) -> list[BaseMessageParam]:
-        """Converts OpenAI message params to base message params."""
-        converted = []
-        for message_param in message_params:
-            contents = []
-            content = message_param.get("content")
-            if (
-                message_param["role"] == "tool"
-                and "name" in message_param
-                and "content" in message_param
-            ):
-                converted.append(
-                    BaseMessageParam(
-                        role="tool",
-                        content=[
-                            ToolResultPart(
-                                type="tool_result",
-                                name=message_param["name"],
-                                content=message_param["content"],
-                                id=message_param["tool_call_id"],
-                                is_error=False,
-                            )
-                        ],
-                    )
-                )
-                continue
-            elif isinstance(content, str):
-                converted.append(
-                    BaseMessageParam(role=message_param["role"], content=content)
-                )
-                continue
-            elif isinstance(content, Iterable):
-                for part in content:
-                    if part["type"] == "text":
-                        contents.append(TextPart(type="text", text=part["text"]))
-                    elif part["type"] == "image_url":
-                        image_url = part["image_url"]
-                        contents.append(
-                            ImageURLPart(
-                                type="image_url",
-                                url=image_url["url"],
-                                detail=image_url.get("detail", None),
-                            )
-                        )
-                    elif part["type"] == "input_audio":
-                        input_audio = part["input_audio"]
-                        contents.append(
-                            AudioPart(
-                                type="audio",
-                                media_type=f"audio/{input_audio['format']}",
-                                audio=input_audio["data"],
-                            )
-                        )
-                    else:
-                        raise ValueError(part["refusal"])  # pyright: ignore [reportGeneralTypeIssues]
-            if tool_calls := message_param.get("tool_calls"):
-                for tool_call in tool_calls:
-                    contents.append(
-                        ToolCallPart(
-                            type="tool_call",
-                            name=tool_call["function"]["name"],
-                            id=tool_call["id"],
-                            args=json.loads(tool_call["function"]["arguments"]),
-                        )
-                    )
-            if contents:
-                converted.append(
-                    BaseMessageParam(role=message_param["role"], content=contents)
-                )
-        return converted

mirascope/core/openai/_utils/_setup_call.py

@@ -1,155 +0,0 @@
-"""This module contains the setup_call function for OpenAI tools."""
-
-import inspect
-import warnings
-from collections.abc import Awaitable, Callable
-from typing import Any, cast, overload
-
-from openai import AsyncAzureOpenAI, AsyncOpenAI, AzureOpenAI, OpenAI
-from openai.types.chat import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ChatCompletionMessageParam,
-    ChatCompletionUserMessageParam,
-)
-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 OpenAICallKwargs
-from ..call_params import OpenAICallParams
-from ..dynamic_config import AsyncOpenAIDynamicConfig, OpenAIDynamicConfig
-from ..tool import GenerateOpenAIStrictToolJsonSchema, OpenAITool
-from ._convert_common_call_params import convert_common_call_params
-from ._convert_message_params import convert_message_params
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: AsyncOpenAI | AsyncAzureOpenAI | None,
-    fn: Callable[..., Awaitable[AsyncOpenAIDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: AsyncOpenAIDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: OpenAICallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[ChatCompletion, ChatCompletionChunk],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    OpenAICallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: OpenAI | AzureOpenAI | None,
-    fn: Callable[..., OpenAIDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: OpenAIDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: OpenAICallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletion, ChatCompletionChunk],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    OpenAICallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: OpenAI | AsyncOpenAI | AzureOpenAI | AsyncAzureOpenAI | None,
-    fn: Callable[..., OpenAIDynamicConfig]
-    | Callable[..., Awaitable[AsyncOpenAIDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: OpenAIDynamicConfig | AsyncOpenAIDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: OpenAICallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletion, ChatCompletionChunk]
-    | AsyncCreateFn[ChatCompletion, ChatCompletionChunk],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    OpenAICallKwargs,
-]:
-    prompt_template, messages, tool_types, base_call_kwargs = _utils.setup_call(
-        fn,
-        fn_args,
-        dynamic_config,
-        tools,
-        OpenAITool,
-        call_params,
-        convert_common_call_params,
-    )
-    call_kwargs = cast(OpenAICallKwargs, base_call_kwargs)
-    messages = cast(list[BaseMessageParam | ChatCompletionMessageParam], messages)
-    messages = convert_message_params(messages)
-    if json_mode:
-        if response_model and response_model.model_config.get("strict", False):
-            call_kwargs["response_format"] = {
-                "type": "json_schema",
-                "json_schema": {
-                    "name": response_model.__name__,
-                    "description": response_model.__doc__ or DEFAULT_TOOL_DOCSTRING,
-                    "strict": True,
-                    "schema": response_model.model_json_schema(
-                        schema_generator=GenerateOpenAIStrictToolJsonSchema
-                    ),
-                },
-            }
-        else:
-            call_kwargs["response_format"] = {"type": "json_object"}
-            json_mode_content = _utils.json_mode_content(response_model).strip()
-            messages.append(
-                ChatCompletionUserMessageParam(role="user", 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"
-    if stream:
-        call_kwargs["stream_options"] = (
-            {"include_usage": True}
-            if "stream_options" not in call_kwargs
-            else call_kwargs["stream_options"].update({"include_usage": True})  # pyright: ignore [reportOptionalMemberAccess]
-        )
-    call_kwargs |= {"model": model, "messages": messages}
-
-    if client is None:
-        client = AsyncOpenAI() if inspect.iscoroutinefunction(fn) else OpenAI()
-    create = (
-        get_async_create_fn(client.chat.completions.create)
-        if isinstance(client, AsyncOpenAI)
-        else get_create_fn(client.chat.completions.create)
-    )
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/openai/call_params.py

@@ -1,91 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from openai.types.chat import (
-    ChatCompletionStreamOptionsParam,
-    ChatCompletionToolChoiceOptionParam,
-)
-from openai.types.chat.completion_create_params import ResponseFormat
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-if TYPE_CHECKING:
-    from openai.types.chat.chat_completion_audio_param import (  # pyright: ignore [reportMissingImports]
-        ChatCompletionAudioParam,
-        ChatCompletionModality,  # pyright: ignore [reportAttributeAccessIssue]
-    )
-    from openai.types.chat.chat_completion_reasoning_effort import (  # pyright: ignore [reportMissingImports]
-        ChatCompletionReasoningEffort,  # pyright: ignore [reportAttributeAccessIssue]
-    )
-else:
-    try:
-        from openai.types.chat.chat_completion_audio_param import (  # pyright: ignore [reportMissingImports]
-            ChatCompletionAudioParam,
-            ChatCompletionModality,
-        )
-    except ImportError:
-
-        class ChatCompletionAudioParam: ...
-
-        class ChatCompletionModality: ...
-
-    try:
-        from openai.types.chat.chat_completion_reasoning_effort import (  # pyright: ignore [reportMissingImports]
-            ChatCompletionReasoningEffort,
-        )
-    except ImportError:
-
-        class ChatCompletionReasoningEffort: ...
-
-
-class OpenAICallParams(BaseCallParams):
-    """The parameters to use when calling the OpenAI API.
-
-    [OpenAI API Reference](https://platform.openai.com/docs/api-reference/chat/create)
-
-    Attributes:
-        audio: ...
-        frequency_penalty: ...
-        logit_bias: ...
-        logprobs: ...
-        max_tokens: ...
-        modalities: ...
-        n: ...
-        parallel_tool_calls: ...
-        presence_penalty: ...
-        reasoning_effort: ...
-        response_format: ...
-        seed: ...
-        stop: ...
-        stream_options: ...
-        temperature: ...
-        tool_choice: ...
-        top_logprobs: ...
-        top_p: ...
-        user: ...
-    """
-
-    audio: NotRequired[ChatCompletionAudioParam | None]
-    extra_headers: NotRequired[dict[str, str] | None]
-    frequency_penalty: NotRequired[float | None]
-    logit_bias: NotRequired[dict[str, int] | None]
-    logprobs: NotRequired[bool | None]
-    max_tokens: NotRequired[int | None]
-    modalities: NotRequired[list[ChatCompletionModality] | None]
-    n: NotRequired[int | None]
-    parallel_tool_calls: NotRequired[bool]
-    presence_penalty: NotRequired[float | None]
-    reasoning_effort: NotRequired[ChatCompletionReasoningEffort | None]
-    response_format: NotRequired[ResponseFormat]
-    seed: NotRequired[int | None]
-    stop: NotRequired[str | list[str] | None]
-    stream_options: NotRequired[ChatCompletionStreamOptionsParam | None]
-    temperature: NotRequired[float | None]
-    tool_choice: NotRequired[ChatCompletionToolChoiceOptionParam]
-    top_logprobs: NotRequired[int | None]
-    top_p: NotRequired[float | None]
-    user: NotRequired[str]