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

mirascope/core/openai/stream.py

@@ -1,185 +0,0 @@
-"""The `OpenAIStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from collections.abc import AsyncGenerator, Generator
-
-from openai.types.chat import (
-    ChatCompletion,
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionMessage,
-    ChatCompletionMessageParam,
-    ChatCompletionMessageToolCall,
-    ChatCompletionMessageToolCallParam,
-    ChatCompletionToolMessageParam,
-    ChatCompletionToolParam,
-    ChatCompletionUserMessageParam,
-)
-from openai.types.chat.chat_completion import Choice
-from openai.types.chat.chat_completion_message_tool_call_param import Function
-from openai.types.completion_usage import CompletionUsage
-
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from .call_params import OpenAICallParams
-from .call_response import OpenAICallResponse
-from .call_response_chunk import OpenAICallResponseChunk
-from .dynamic_config import OpenAIDynamicConfig
-from .tool import OpenAITool
-
-FinishReason = Choice.__annotations__["finish_reason"]
-
-
-class OpenAIStream(
-    BaseStream[
-        OpenAICallResponse,
-        OpenAICallResponseChunk,
-        ChatCompletionUserMessageParam,
-        ChatCompletionAssistantMessageParam,
-        ChatCompletionToolMessageParam,
-        ChatCompletionMessageParam,
-        OpenAITool,
-        ChatCompletionToolParam,
-        OpenAIDynamicConfig,
-        OpenAICallParams,
-        FinishReason,
-    ]
-):
-    """A class for convenience around streaming OpenAI LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.openai import openai_call
-
-
-    @openai_call("gpt-4o-mini", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    stream = recommend_book("fantasy")  # returns `OpenAIStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    audio_id: str | None = None
-
-    _provider = "openai"
-
-    def __iter__(
-        self,
-    ) -> Generator[tuple[OpenAICallResponseChunk, OpenAITool | None], None, None]:
-        for chunk, tool in super().__iter__():
-            if (
-                (choices := chunk.chunk.choices)
-                and (audio := getattr(choices[0].delta, "audio", None))
-                and (audio_id := audio.get("id"))
-            ):
-                self.audio_id = audio_id
-            yield chunk, tool
-
-    def __aiter__(
-        self,
-    ) -> AsyncGenerator[tuple[OpenAICallResponseChunk, OpenAITool | None], None]:
-        aiter = super().__aiter__()
-
-        async def generator() -> AsyncGenerator[
-            tuple[OpenAICallResponseChunk, OpenAITool | None], None
-        ]:
-            async for chunk, tool in aiter:
-                if (
-                    (choices := chunk.chunk.choices)
-                    and (audio := getattr(choices[0].delta, "audio", None))
-                    and (audio_id := audio.get("id"))
-                ):
-                    self.audio_id = audio_id
-                yield chunk, tool
-
-        return generator()
-
-    def _construct_message_param(
-        self,
-        tool_calls: list[ChatCompletionMessageToolCall] | None = None,
-        content: str | None = None,
-    ) -> ChatCompletionAssistantMessageParam:
-        """Constructs the message parameter for the assistant."""
-        message_param = ChatCompletionAssistantMessageParam(
-            role="assistant", content=content
-        )
-        if tool_calls:
-            message_param["tool_calls"] = [
-                ChatCompletionMessageToolCallParam(
-                    type="function",
-                    function=Function(
-                        arguments=tool_call.function.arguments,
-                        name=tool_call.function.name,
-                    ),
-                    id=tool_call.id,
-                )
-                for tool_call in tool_calls
-            ]
-        if self.audio_id:
-            message_param["audio"] = {"id": self.audio_id}
-        return message_param
-
-    def construct_call_response(self) -> OpenAICallResponse:
-        """Constructs the call response from a consumed OpenAIStream.
-
-        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."
-            )
-        message = {
-            "role": self.message_param["role"],
-            "content": self.message_param.get("content", ""),
-            "tool_calls": self.message_param.get("tool_calls", []),
-        }
-        if not self.input_tokens and not self.output_tokens:
-            usage = None
-        else:
-            usage = CompletionUsage(
-                prompt_tokens=int(self.input_tokens or 0),
-                completion_tokens=int(self.output_tokens or 0),
-                total_tokens=int(self.input_tokens or 0) + int(self.output_tokens or 0),
-            )
-        completion = ChatCompletion(
-            id=self.id if self.id else "",
-            model=self.model,
-            choices=[
-                Choice(
-                    finish_reason=self.finish_reasons[0]
-                    if self.finish_reasons
-                    else "stop",
-                    index=0,
-                    message=ChatCompletionMessage.model_validate(message),
-                )
-            ],
-            created=0,
-            object="chat.completion",
-            usage=usage,
-        )
-        return OpenAICallResponse(
-            metadata=self.metadata,
-            response=completion,
-            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:
-        return super().cost_metadata

mirascope/core/openai/tool.py

@@ -1,101 +0,0 @@
-"""The `OpenAITool` class for easy tool usage with OpenAI LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-from openai.types.chat import (
-    ChatCompletionMessageToolCall,
-    ChatCompletionToolParam,
-)
-from openai.types.shared_params import FunctionDefinition
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool, GenerateJsonSchemaNoTitles, ToolConfig
-from ..base._partial import partial
-
-
-class GenerateOpenAIStrictToolJsonSchema(GenerateJsonSchemaNoTitles):
-    _openai_strict = True
-
-
-class OpenAIToolConfig(ToolConfig, total=False):
-    """A tool configuration for OpenAI-specific features."""
-
-    strict: bool
-
-
-class OpenAITool(BaseTool):
-    """A class for defining tools for OpenAI LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.openai import openai_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @openai_call("gpt-4o-mini", tools=[format_book])
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `OpenAITool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "openai"
-    __tool_config_type__ = OpenAIToolConfig
-
-    tool_call: SkipJsonSchema[ChatCompletionMessageToolCall]
-
-    @classmethod
-    def tool_schema(cls) -> ChatCompletionToolParam:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.openai import OpenAITool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = OpenAITool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the OpenAI-specific tool schema
-        ```
-        """
-        fn = FunctionDefinition(name=cls._name(), description=cls._description())
-        schema_generator = GenerateJsonSchemaNoTitles
-        if cls.tool_config.get("strict", False):
-            fn["strict"] = True
-            schema_generator = GenerateOpenAIStrictToolJsonSchema
-        model_schema = cls.model_json_schema(schema_generator=schema_generator)
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema
-        return ChatCompletionToolParam(function=fn, type="function")
-
-    @classmethod
-    def from_tool_call(
-        cls, tool_call: ChatCompletionMessageToolCall, allow_partial: bool = False
-    ) -> OpenAITool:
-        """Constructs an `OpenAITool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The OpenAI tool call from which to construct this tool instance.
-            allow_partial: Whether to allow partial JSON data.
-        """
-        model_json = {"tool_call": tool_call.model_dump()}
-        if args := tool_call.function.arguments:
-            model_json |= cls._dict_from_json(args, allow_partial)
-        if allow_partial:
-            return partial(cls, {"tool_call", "delta"}).model_validate(model_json)
-        return cls.model_validate(model_json)

mirascope/core/vertex/__init__.py

@@ -1,45 +0,0 @@
-"""The Mirascope Vertex Module."""
-
-import inspect
-import warnings
-from typing import TypeAlias
-
-from google.cloud.aiplatform_v1beta1.types import FunctionResponse
-from vertexai.generative_models import Content
-
-from ..base import BaseMessageParam
-from ._call import vertex_call
-from ._call import vertex_call as call
-from .call_params import VertexCallParams
-from .call_response import VertexCallResponse
-from .call_response_chunk import VertexCallResponseChunk
-from .dynamic_config import VertexDynamicConfig
-from .stream import VertexStream
-from .tool import VertexTool
-
-VertexMessageParam: TypeAlias = Content | FunctionResponse | BaseMessageParam
-
-warnings.warn(
-    inspect.cleandoc("""
-    The `mirascope.core.gemini` module is deprecated and will be removed in a future release.
-    Please use the `mirascope.core.google` module instead.
-                     
-    You can use Vertex AI by setting a custom `client` or environment variables.
-    See these docs for reference:
-        - Google AI SDK Custom Client: https://googleapis.github.io/python-genai/#create-a-client
-        - Mirascope Google Custom Client: https://mirascope.com/learn/calls/#__tabbed_39_5
-    """),
-    category=DeprecationWarning,
-)
-
-__all__ = [
-    "VertexCallParams",
-    "VertexCallResponse",
-    "VertexCallResponseChunk",
-    "VertexDynamicConfig",
-    "VertexMessageParam",
-    "VertexStream",
-    "VertexTool",
-    "call",
-    "vertex_call",
-]

mirascope/core/vertex/_call.py

@@ -1,62 +0,0 @@
-"""The `vertex_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 VertexCallParams
-from .call_response import VertexCallResponse
-from .call_response_chunk import VertexCallResponseChunk
-from .stream import VertexStream
-from .tool import VertexTool
-
-vertex_call = call_factory(
-    TCallResponse=VertexCallResponse,
-    TCallResponseChunk=VertexCallResponseChunk,
-    TStream=VertexStream,
-    TToolType=VertexTool,
-    default_call_params=VertexCallParams(),
-    setup_call=setup_call,
-    get_json_output=get_json_output,
-    handle_stream=handle_stream,  # pyright: ignore [reportArgumentType]
-    handle_stream_async=handle_stream_async,  # pyright: ignore [reportArgumentType]
-)
-"""A decorator for calling the Vertex API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Vertex 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.vertex import vertex_call
-
-
-@vertex_call("gemini-1.5-flash")
-def recommend_book(genre: str) -> str:
-    return f"Recommend a {genre} book"
-
-response = recommend_book("fantasy")
-print(response.content)
-```
-
-Args:
-    model (str): The Vertex 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 Vertex API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[VertexCallResponse | ResponseModelT], Any]): A function
-        for parsing the call response whose value will be returned in place of the
-        original call response.
-    json_modem (bool): Whether to use JSON Mode.
-    client (object): An optional custom client to use in place of the default client.
-    call_params (VertexCallParams): The `VertexCallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a Vertex API
-        call.
-"""

mirascope/core/vertex/_call_kwargs.py

@@ -1,12 +0,0 @@
-"""This module contains the type definition for the Vertex call keyword arguments."""
-
-from collections.abc import Sequence
-
-from vertexai.generative_models import Content, Tool
-
-from ..base import BaseCallKwargs
-from .call_params import VertexCallParams
-
-
-class VertexCallKwargs(VertexCallParams, BaseCallKwargs[Tool]):
-    contents: Sequence[Content]

mirascope/core/vertex/_utils/__init__.py

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

@@ -1,37 +0,0 @@
-from typing import cast
-
-from vertexai.generative_models import GenerationConfig
-
-from ...base.call_params import CommonCallParams
-from ..call_params import VertexCallParams
-
-VERTEX_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "max_output_tokens",
-    "top_p": "top_p",
-    "stop": "stop_sequences",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> VertexCallParams:
-    """Convert CommonCallParams to Vertex parameters."""
-    generation_config = {}
-
-    for key, value in common_params.items():
-        if key not in VERTEX_PARAM_MAPPING or value is None:
-            continue
-
-        if key == "stop":
-            generation_config["stop_sequences"] = (
-                [value] if isinstance(value, str) else value
-            )
-        else:
-            generation_config[VERTEX_PARAM_MAPPING[key]] = value
-
-    if not generation_config:
-        return cast(VertexCallParams, {})
-
-    return cast(
-        VertexCallParams,
-        {"generation_config": cast(GenerationConfig, generation_config)},
-    )

mirascope/core/vertex/_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] = {
-    "FINISH_REASON_UNSPECIFIED": "stop",
-    "STOP": "stop",
-    "MAX_TOKENS": "length",
-    "SAFETY": "content_filter",
-    "RECITATION": "stop",
-    "OTHER": "stop",
-}
-
-
-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
-    )

mirascope/core/vertex/_utils/_convert_message_params.py

@@ -1,171 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `Content`"""
-
-import base64
-import io
-
-import PIL.Image
-from google.cloud.aiplatform_v1beta1.types import content as gapic_content_types
-from google.cloud.aiplatform_v1beta1.types import tool as gapic_tool_types
-from vertexai.generative_models import Content, Image, Part
-
-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 | Content],
-) -> list[Content]:
-    converted_message_params = []
-    for message_param in message_params:
-        if isinstance(message_param, Content):
-            converted_message_params.append(message_param)
-        elif (role := message_param.role) == "system":
-            content = message_param.content
-            if not isinstance(content, str):
-                raise ValueError(
-                    "System message content must be a single text string."
-                )  # pragma: no cover
-            converted_message_params += [
-                Content(
-                    role="system",
-                    parts=[
-                        Part.from_text(content) if isinstance(content, str) else content
-                    ],
-                ),
-            ]
-        elif isinstance((content := message_param.content), str):
-            converted_message_params.append(
-                Content(role="user", parts=[Part.from_text(content)])
-            )
-        else:
-            converted_content: list[Part] = []
-            for part in content:
-                if part.type == "text":
-                    converted_content.append(Part.from_text(part.text))
-                elif part.type == "image":
-                    if part.media_type not in [
-                        "image/jpeg",
-                        "image/png",
-                        "image/webp",
-                        "image/heic",
-                        "image/heif",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported image media type: {part.media_type}. "
-                            "Vertex currently only supports JPEG, PNG, WebP, HEIC, "
-                            "and HEIF images."
-                        )
-                    image = Image.from_bytes(part.image)
-                    converted_content.append(Part.from_image(image))
-                elif part.type == "image_url":
-                    # Should download the image to determine the media type
-                    image = PIL.Image.open(io.BytesIO(_load_media(part.url)))
-                    media_type = (
-                        PIL.Image.MIME[image.format]
-                        if image.format
-                        else "image/unknown"
-                    )
-                    if media_type not in [
-                        "image/jpeg",
-                        "image/png",
-                        "image/webp",
-                        "image/heic",
-                        "image/heif",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported image media type: {media_type}. "
-                            "Gemini currently only supports JPEG, PNG, WebP, HEIC, "
-                            "and HEIF images."
-                        )
-                    converted_content.append(
-                        Part.from_uri(part.url, mime_type=media_type)
-                    )
-                elif part.type == "audio":
-                    if part.media_type not in [
-                        "audio/wav",
-                        "audio/mp3",
-                        "audio/aiff",
-                        "audio/aac",
-                        "audio/ogg",
-                        "audio/flac",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported audio media type: {part.media_type}. "
-                            "Vertex currently only supports WAV, MP3, AIFF, AAC, OGG, "
-                            "and FLAC audio file types."
-                        )
-                    converted_content.append(
-                        Part.from_data(
-                            mime_type=part.media_type,
-                            data=part.audio
-                            if isinstance(part.audio, bytes)
-                            else base64.b64decode(part.audio),
-                        )
-                    )
-                elif part.type == "audio_url":
-                    # Should download the audio to determine the media type
-                    audio = _load_media(part.url)
-                    audio_type = f"audio/{get_audio_type(audio)}"
-                    if audio_type not in [
-                        "audio/wav",
-                        "audio/mp3",
-                        "audio/aiff",
-                        "audio/aac",
-                        "audio/ogg",
-                        "audio/flac",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported audio media type: {audio_type}. "
-                            "Gemini currently only supports WAV, MP3, AIFF, AAC, OGG, "
-                            "and FLAC audio file types."
-                        )
-                    converted_content.append(
-                        Part.from_uri(part.url, mime_type=audio_type)
-                    )
-                elif part.type == "tool_call":
-                    if converted_content:
-                        converted_message_params.append(
-                            Content(role=role, parts=converted_content)
-                        )
-                        converted_content = []
-                    raw_gapic_part = gapic_content_types.Part(
-                        function_call=gapic_tool_types.FunctionCall(
-                            name=part.name, args=part.args
-                        )
-                    )
-                    converted_message_params.append(
-                        Content(
-                            role=role,
-                            parts=[Part._from_gapic(raw_gapic_part)],
-                        )
-                    )
-                elif part.type == "tool_result":
-                    if converted_content:
-                        converted_message_params.append(
-                            Content(role=role, parts=converted_content)
-                        )
-                        converted_content = []
-                    converted_message_params.append(
-                        Content(
-                            role=role,
-                            parts=[
-                                Part.from_function_response(
-                                    name=part.name,
-                                    response={
-                                        "content": {"result": part.content},
-                                    },
-                                )
-                            ],
-                        )
-                    )
-                else:
-                    raise ValueError(
-                        "Vertex currently only supports text, image, and audio parts. "
-                        f"Part provided: {part.type}"
-                    )
-            if converted_content:
-                converted_message_params.append(
-                    Content(role=role, parts=converted_content)
-                )
-    return converted_message_params