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

mirascope/core/azure/call_response.py

@@ -1,215 +0,0 @@
-"""This module contains the `AzureCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-from typing import cast
-
-from azure.ai.inference.models import (
-    AssistantMessage,
-    ChatCompletions,
-    ChatCompletionsToolDefinition,
-    ChatRequestMessage,
-    CompletionsUsage,
-    ToolMessage,
-    UserMessage,
-)
-from pydantic import SerializeAsAny, SkipValidation, computed_field
-
-from .. import BaseMessageParam
-from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import CostMetadata, FinishReason
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-from ._utils._message_param_converter import AzureMessageParamConverter
-from .call_params import AzureCallParams
-from .dynamic_config import AsyncAzureDynamicConfig, AzureDynamicConfig
-from .tool import AzureTool
-
-
-class AzureCallResponse(
-    BaseCallResponse[
-        ChatCompletions,
-        AzureTool,
-        ChatCompletionsToolDefinition,
-        AsyncAzureDynamicConfig | AzureDynamicConfig,
-        ChatRequestMessage,
-        AzureCallParams,
-        UserMessage,
-        AzureMessageParamConverter,
-    ]
-):
-    """A convenience wrapper around the Azure `ChatCompletion` response.
-
-    When calling the Azure API using a function decorated with `azure_call`, the
-    response will be an `AzureCallResponse` instance with properties that allow for
-    more convenience access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.azure import azure_call
-
-
-    @azure_call("gpt-4o")
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")  # response is an `AzureCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    response: SkipValidation[ChatCompletions]
-    _message_converter: type[AzureMessageParamConverter] = AzureMessageParamConverter
-
-    _provider = "azure"
-
-    @computed_field
-    @property
-    def content(self) -> str:
-        """Returns the content of the chat completion for the 0th choice."""
-        message = self.response.choices[0].message
-        return message.content if message.content is not None else ""
-
-    @computed_field
-    @property
-    def finish_reasons(self) -> list[str]:
-        """Returns the finish reasons of the response."""
-        return [str(choice.finish_reason) for choice in self.response.choices]
-
-    @computed_field
-    @property
-    def model(self) -> str:
-        """Returns the name of the response model."""
-        return self.response.model
-
-    @computed_field
-    @property
-    def id(self) -> str:
-        """Returns the id of the response."""
-        return self.response.id
-
-    @property
-    def usage(self) -> CompletionsUsage | None:
-        """Returns the usage of the chat completion."""
-        return self.response.usage
-
-    @computed_field
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        return self.usage.prompt_tokens if self.usage else None
-
-    @computed_field
-    @property
-    def cached_tokens(self) -> int | None:
-        """Returns the number of cached tokens."""
-        return None
-
-    @computed_field
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        return self.usage.completion_tokens if self.usage else None
-
-    @computed_field
-    @cached_property
-    def message_param(self) -> SerializeAsAny[AssistantMessage]:
-        """Returns the assistants's response as a message parameter."""
-        message_param = self.response.choices[0].message
-        return AssistantMessage(
-            content=message_param.content, tool_calls=message_param.tool_calls
-        )
-
-    @cached_property
-    def tools(self) -> list[AzureTool] | None:
-        """Returns any available tool calls as their `AzureTool` definition.
-
-        Raises:
-            ValidationError: if a tool call doesn't match the tool's schema.
-            ValueError: if the model refused to response, in which case the error
-                message will be the refusal.
-        """
-
-        tool_calls = self.response.choices[0].message.tool_calls
-        if not self.tool_types or not tool_calls:
-            return None
-
-        extracted_tools = []
-        for tool_call in tool_calls:
-            for tool_type in self.tool_types:
-                if tool_call.function.name == tool_type._name():
-                    extracted_tools.append(tool_type.from_tool_call(tool_call))
-                    break
-
-        return extracted_tools
-
-    @cached_property
-    def tool(self) -> AzureTool | None:
-        """Returns the 0th tool for the 0th choice message.
-
-        Raises:
-            ValidationError: if the tool call doesn't match the tool's schema.
-            ValueError: if the model refused to response, in which case the error
-                message will be the refusal.
-        """
-        if tools := self.tools:
-            return tools[0]
-        return None
-
-    @classmethod
-    def _get_tool_message(cls, tool: AzureTool, output: str) -> ToolMessage:
-        """Returns a tool message for the tool call."""
-        tool_message = ToolMessage(
-            content=output,
-            tool_call_id=tool.tool_call.id,  # pyright: ignore [reportOptionalMemberAccess]
-        )
-        tool_message.name = tool._name()  # pyright: ignore [reportCallIssue, reportAttributeAccessIssue]
-        return tool_message
-
-    @classmethod
-    @transform_tool_outputs
-    def tool_message_params(
-        cls, tools_and_outputs: Sequence[tuple[AzureTool, str]]
-    ) -> list[ToolMessage]:
-        """Returns the tool message parameters for tool call results.
-
-        Args:
-            tools_and_outputs: The sequence of tools and their outputs from which the tool
-                message parameters should be constructed.
-
-        Returns:
-            The list of constructed `ChatCompletionToolMessageParam` parameters.
-        """
-        return [
-            cls._get_tool_message(tool, output) for tool, output in tools_and_outputs
-        ]
-
-    @property
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        """Provider-agnostic finish reasons."""
-        return _convert_finish_reasons_to_common_finish_reasons(
-            cast(list[str], self.finish_reasons)
-        )
-
-    @property
-    def common_message_param(self) -> BaseMessageParam:
-        return AzureMessageParamConverter.from_provider([self.message_param])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return AzureMessageParamConverter.from_provider([self.user_message_param])[0]
-
-    @computed_field
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Get metadata required for cost calculation."""
-        return super().cost_metadata

mirascope/core/azure/call_response_chunk.py

@@ -1,105 +0,0 @@
-"""This module contains the `AzureCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from typing import cast
-
-from azure.ai.inference.models import (
-    CompletionsFinishReason,
-    CompletionsUsage,
-    StreamingChatCompletionsUpdate,
-)
-from pydantic import SkipValidation
-
-from ..base import BaseCallResponseChunk
-from ..base.types import CostMetadata, FinishReason
-
-
-class AzureCallResponseChunk(
-    BaseCallResponseChunk[StreamingChatCompletionsUpdate, CompletionsFinishReason]
-):
-    """A convenience wrapper around the Azure `ChatCompletionChunk` streamed chunks.
-
-    When calling the Azure API using a function decorated with `azure_call` and
-    `stream` set to `True`, the stream will contain `AzureResponseChunk` instances with
-    properties that allow for more convenient access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.azure import azure_call
-
-
-    @azure_call("gpt-4o-mini", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    stream = recommend_book("fantasy")  # response is an `AzureStream`
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    chunk: SkipValidation[StreamingChatCompletionsUpdate]
-
-    @property
-    def content(self) -> str:
-        """Returns the content for the 0th choice delta."""
-        delta = None
-        if self.chunk.choices:
-            delta = self.chunk.choices[0].delta
-        return delta.content if delta is not None and delta.content else ""
-
-    @property
-    def finish_reasons(self) -> list[CompletionsFinishReason]:
-        """Returns the finish reasons of the response."""
-        return [
-            finish_reason
-            if isinstance(finish_reason, CompletionsFinishReason)
-            else CompletionsFinishReason(finish_reason)
-            for choice in self.chunk.choices
-            if (finish_reason := choice.finish_reason)
-        ]
-
-    @property
-    def model(self) -> str:
-        """Returns the name of the response model."""
-        return self.chunk.model
-
-    @property
-    def id(self) -> str:
-        """Returns the id of the response."""
-        return self.chunk.id
-
-    @property
-    def usage(self) -> CompletionsUsage | None:
-        """Returns the usage of the chat completion."""
-        return self.chunk.usage
-
-    @property
-    def input_tokens(self) -> int | None:
-        """Returns the number of input tokens."""
-        return self.usage.prompt_tokens if self.usage else None
-
-    @property
-    def cached_tokens(self) -> int:
-        """Returns the number of cached tokens."""
-        return 0
-
-    @property
-    def output_tokens(self) -> int | None:
-        """Returns the number of output tokens."""
-        return self.usage.completion_tokens if self.usage else None
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Returns the cost metadata."""
-        return super().cost_metadata
-
-    @property
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        """Provider-agnostic finish reasons."""
-        return cast(list[FinishReason], self.finish_reasons)

mirascope/core/azure/dynamic_config.py

@@ -1,30 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from azure.ai.inference import ChatCompletionsClient
-from azure.ai.inference.aio import ChatCompletionsClient as AsyncChatCompletionsClient
-from azure.ai.inference.models import ChatRequestMessage
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import AzureCallParams
-
-AsyncAzureDynamicConfig = BaseDynamicConfig[
-    ChatRequestMessage | BaseMessageParam, AzureCallParams, AsyncChatCompletionsClient
-]
-AzureDynamicConfig = BaseDynamicConfig[
-    ChatRequestMessage | BaseMessageParam, AzureCallParams, ChatCompletionsClient
-]
-"""The function return type for functions wrapped with the `azure_call` decorator.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.azure import AzureDynamicConfig, azure_call
-
-
-@azure_call("gpt-4o-mini")
-@prompt_template("Recommend a {capitalized_genre} book")
-def recommend_book(genre: str) -> AzureDynamicConfig:
-    return {"computed_fields": {"capitalized_genre": genre.capitalize()}}
-```
-"""

mirascope/core/azure/stream.py

@@ -1,147 +0,0 @@
-"""The `AzureStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-import datetime
-
-from azure.ai.inference.models import (
-    AssistantMessage,
-    ChatChoice,
-    ChatCompletions,
-    ChatCompletionsToolCall,
-    ChatCompletionsToolDefinition,
-    ChatRequestMessage,
-    ChatResponseMessage,
-    CompletionsFinishReason,
-    CompletionsUsage,
-    FunctionCall,
-    ToolMessage,
-    UserMessage,
-)
-
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from .call_params import AzureCallParams
-from .call_response import AzureCallResponse
-from .call_response_chunk import AzureCallResponseChunk
-from .dynamic_config import AsyncAzureDynamicConfig, AzureDynamicConfig
-from .tool import AzureTool
-
-
-class AzureStream(
-    BaseStream[
-        AzureCallResponse,
-        AzureCallResponseChunk,
-        UserMessage,
-        AssistantMessage,
-        ToolMessage,
-        ChatRequestMessage,
-        AzureTool,
-        ChatCompletionsToolDefinition,
-        AsyncAzureDynamicConfig | AzureDynamicConfig,
-        AzureCallParams,
-        CompletionsFinishReason,
-    ]
-):
-    """A class for convenience around streaming Azure LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.azure import azure_call
-
-
-    @azure_call("gpt-4o-mini", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    stream = recommend_book("fantasy")  # returns `AzureStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "azure"
-
-    def _construct_message_param(
-        self,
-        tool_calls: list[ChatCompletionsToolCall] | None = None,
-        content: str | None = None,
-    ) -> AssistantMessage:
-        """Constructs the message parameter for the assistant."""
-        message_param = AssistantMessage(content=content)
-        if tool_calls:
-            message_param["tool_calls"] = [
-                ChatCompletionsToolCall(
-                    function=FunctionCall(
-                        arguments=tool_call.function.arguments,
-                        name=tool_call.function.name,
-                    ),
-                    id=tool_call.id,
-                )
-                for tool_call in tool_calls
-            ]
-        return message_param
-
-    def construct_call_response(self) -> AzureCallResponse:
-        """Constructs the call response from a consumed AzureStream.
-
-        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 = ChatResponseMessage(
-            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 = CompletionsUsage(
-                completion_tokens=0, prompt_tokens=0, total_tokens=0
-            )
-        else:
-            usage = CompletionsUsage(
-                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 = ChatCompletions(
-            id=self.id if self.id else "",
-            model=self.model,
-            choices=[
-                ChatChoice(
-                    finish_reason=self.finish_reasons[0]
-                    if self.finish_reasons
-                    else "stop",
-                    index=0,
-                    message=message,
-                )
-            ],
-            created=datetime.datetime.now(),
-            usage=usage,
-        )
-        return AzureCallResponse(
-            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:
-        """Get metadata required for cost calculation."""
-        return super().cost_metadata

mirascope/core/azure/tool.py

@@ -1,93 +0,0 @@
-"""The `AzureTool` class for easy tool usage with Azure LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-import jiter
-from azure.ai.inference.models import (
-    ChatCompletionsToolCall,
-    ChatCompletionsToolDefinition,
-    FunctionDefinition,
-)
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool, GenerateJsonSchemaNoTitles, ToolConfig
-
-
-class GenerateAzureStrictToolJsonSchema(GenerateJsonSchemaNoTitles):
-    _azure_strict = True
-
-
-class AzureToolConfig(ToolConfig, total=False):
-    """A tool configuration for Azure-specific features."""
-
-    strict: bool
-
-
-class AzureTool(BaseTool):
-    """A class for defining tools for Azure LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.azure import azure_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @azure_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 `AzureTool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "azure"
-    __tool_config_type__ = AzureToolConfig
-
-    tool_call: SkipJsonSchema[ChatCompletionsToolCall]
-
-    @classmethod
-    def tool_schema(cls) -> ChatCompletionsToolDefinition:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.azure import AzureTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = AzureTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Azure-specific tool schema
-        ```
-        """
-        fn = FunctionDefinition(name=cls._name(), description=cls._description())
-        schema_generator = GenerateJsonSchemaNoTitles
-        model_schema = cls.model_json_schema(schema_generator=schema_generator)
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema
-        return ChatCompletionsToolDefinition(function=fn)
-
-    @classmethod
-    def from_tool_call(cls, tool_call: ChatCompletionsToolCall) -> AzureTool:
-        """Constructs an `AzureTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Azure tool call from which to construct this tool instance.
-        """
-        model_json = {"tool_call": tool_call}
-        if args := tool_call.function.arguments:
-            model_json |= jiter.from_json(args.encode())
-        return cls.model_validate(model_json)

mirascope/core/base/__init__.py

@@ -1,86 +0,0 @@
-"""Mirascope Base Classes."""
-
-from . import _partial, _utils
-from ._call_factory import call_factory
-from ._utils import BaseType
-from .call_kwargs import BaseCallKwargs
-from .call_params import BaseCallParams, CommonCallParams
-from .call_response import BaseCallResponse, transform_tool_outputs
-from .call_response_chunk import BaseCallResponseChunk
-from .dynamic_config import BaseDynamicConfig
-from .from_call_args import FromCallArgs
-from .merge_decorators import merge_decorators
-from .message_param import (
-    AudioPart,
-    AudioURLPart,
-    BaseMessageParam,
-    CacheControlPart,
-    DocumentPart,
-    DocumentURLPart,
-    ImagePart,
-    ImageURLPart,
-    TextPart,
-    ToolCallPart,
-    ToolResultPart,
-)
-from .messages import Messages
-from .metadata import Metadata
-from .prompt import BasePrompt, metadata, prompt_template
-from .response_model_config_dict import ResponseModelConfigDict
-from .stream import BaseStream
-from .structured_stream import BaseStructuredStream
-from .tool import BaseTool, GenerateJsonSchemaNoTitles, ToolConfig
-from .toolkit import BaseToolKit, toolkit_tool
-from .types import (
-    AudioSegment,
-    CostMetadata,
-    JsonableType,
-    LocalProvider,
-    Provider,
-    Usage,
-)
-
-__all__ = [
-    "AudioPart",
-    "AudioSegment",
-    "AudioURLPart",
-    "BaseCallKwargs",
-    "BaseCallParams",
-    "BaseCallResponse",
-    "BaseCallResponseChunk",
-    "BaseDynamicConfig",
-    "BaseMessageParam",
-    "BasePrompt",
-    "BaseStream",
-    "BaseStructuredStream",
-    "BaseTool",
-    "BaseToolKit",
-    "BaseType",
-    "CacheControlPart",
-    "CommonCallParams",
-    "CostMetadata",
-    "DocumentPart",
-    "DocumentURLPart",
-    "FromCallArgs",
-    "GenerateJsonSchemaNoTitles",
-    "ImagePart",
-    "ImageURLPart",
-    "JsonableType",
-    "LocalProvider",
-    "Messages",
-    "Metadata",
-    "ResponseModelConfigDict",
-    "TextPart",
-    "ToolCallPart",
-    "ToolConfig",
-    "ToolResultPart",
-    "Usage",
-    "_partial",
-    "_utils",
-    "call_factory",
-    "merge_decorators",
-    "metadata",
-    "prompt_template",
-    "toolkit_tool",
-    "transform_tool_outputs",
-]