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

mirascope/core/openai/_utils/_convert_common_call_params.py

@@ -1,26 +0,0 @@
-from typing import cast
-
-from ...base.call_params import CommonCallParams
-from ..call_params import OpenAICallParams
-
-OPENAI_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) -> OpenAICallParams:
-    """Convert CommonCallParams to OpenAI parameters."""
-    return cast(
-        OpenAICallParams,
-        {
-            OPENAI_PARAM_MAPPING[key]: value
-            for key, value in common_params.items()
-            if key in OPENAI_PARAM_MAPPING and value is not None
-        },
-    )

mirascope/core/openai/_utils/_convert_message_params.py

@@ -1,148 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ChatCompletionMessageParam`."""
-
-import base64
-import json
-
-from openai.types.chat import ChatCompletionMessageParam
-
-from ...base import BaseMessageParam
-from ...base._utils import get_audio_type
-from ...base._utils._parse_content_template import _load_media
-
-
-def convert_message_params(
-    message_params: list[BaseMessageParam | ChatCompletionMessageParam],
-) -> list[ChatCompletionMessageParam]:
-    converted_message_params = []
-    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(message_param.model_dump())
-        else:
-            converted_content = []
-
-            tool_calls = []
-            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}. OpenAI"
-                            " 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 == "audio":
-                    if part.media_type not in [
-                        "audio/wav",
-                        "audio/mp3",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported audio media type: {part.media_type}. "
-                            "OpenAI currently only supports WAV and MP3 audio file types."
-                        )
-                    data = (
-                        part.audio
-                        if isinstance(part.audio, str)
-                        else base64.b64encode(part.audio).decode("utf-8")
-                    )
-                    converted_content.append(
-                        {
-                            "input_audio": {
-                                "format": part.media_type.split("/")[-1],
-                                "data": data,
-                            },
-                            "type": "input_audio",
-                        }
-                    )
-                elif part.type == "audio_url":
-                    audio = _load_media(part.url)
-                    audio_type = get_audio_type(audio)
-                    if audio_type not in [
-                        "wav",
-                        "mp3",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported audio media type: audio/{audio_type}. "
-                            "OpenAI currently only supports WAV and MP3 audio file types."
-                        )
-                    converted_content.append(
-                        {
-                            "input_audio": {
-                                "format": audio_type,
-                                "data": base64.b64encode(audio).decode("utf-8"),
-                            },
-                            "type": "input_audio",
-                        }
-                    )
-                elif part.type == "tool_call":
-                    tool_calls.append(
-                        {
-                            "function": {
-                                "name": part.name,
-                                "arguments": json.dumps(part.args),
-                            },
-                            "type": "function",
-                            "id": part.id,
-                        }
-                    )
-                elif part.type == "tool_result":
-                    if converted_content:
-                        converted_message_params.append(
-                            {"role": message_param.role, "content": converted_content}
-                        )
-                        converted_content = []
-
-                    converted_message_params.append(
-                        {
-                            "role": "tool",
-                            "tool_call_id": part.id,
-                            "content": part.content,
-                        }
-                    )
-                else:
-                    raise ValueError(
-                        "OpenAI currently only supports text, image and audio parts. "
-                        f"Part provided: {part.type}"
-                    )
-            if tool_calls:
-                converted_message_param = {
-                    "role": "assistant",
-                    "tool_calls": tool_calls,
-                }
-                converted_message_params.append(converted_message_param)
-                if converted_content:
-                    converted_message_param["content"] = converted_content
-            elif converted_content:
-                converted_message_params.append(
-                    {
-                        "role": message_param.role,
-                        "content": converted_content,
-                    }
-                )
-    return converted_message_params

mirascope/core/openai/_utils/_get_json_output.py

@@ -1,31 +0,0 @@
-"""Get the JSON output from a completion response."""
-
-from ..call_response import OpenAICallResponse
-from ..call_response_chunk import OpenAICallResponseChunk
-
-
-def get_json_output(
-    response: OpenAICallResponse | OpenAICallResponseChunk, json_mode: bool
-) -> str:
-    """Get the JSON output from a completion response."""
-    if isinstance(response, OpenAICallResponse):
-        if hasattr(response.response.choices[0].message, "refusal") and (
-            refusal := response.response.choices[0].message.refusal
-        ):
-            raise ValueError(refusal)
-        elif 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/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