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

mirascope/core/cohere/call_response.py

@@ -1,167 +0,0 @@
-"""This module contains the `CohereCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from cohere.types import (
-    ApiMetaBilledUnits,
-    ChatMessage,
-    NonStreamedChatResponse,
-    ToolResult,
-)
-from pydantic import SkipValidation, computed_field
-
-from ..base import BaseCallResponse
-from ._utils import calculate_cost
-from .call_params import CohereCallParams
-from .dynamic_config import CohereDynamicConfig
-from .tool import CohereTool
-
-
-class CohereCallResponse(
-    BaseCallResponse[
-        SkipValidation[NonStreamedChatResponse],
-        CohereTool,
-        CohereDynamicConfig,
-        SkipValidation[ChatMessage],
-        CohereCallParams,
-        SkipValidation[ChatMessage],
-    ]
-):
-    """A convenience wrapper around the Cohere `ChatCompletion` response.
-
-    When calling the Cohere API using a function decorated with `cohere_call`, the
-    response will be an `CohereCallResponse` instance with properties that allow for
-    more convenience access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.cohere import cohere_call
-
-
-    @cohere_call("command-r-plus")
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")  # response is an `CohereCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _provider = "cohere"
-
-    @property
-    def content(self) -> str:
-        """Returns the content of the chat completion for the 0th choice."""
-        return self.response.text
-
-    @property
-    def finish_reasons(self) -> list[str] | None:
-        """Returns the finish reasons of the response."""
-        return [str(self.response.finish_reason)]
-
-    @property
-    def model(self) -> str:
-        """Returns the name of the response model.
-
-        Cohere does not return model, so we return the model provided by the user.
-        """
-        return self._model
-
-    @property
-    def id(self) -> str | None:
-        """Returns the id of the response."""
-        return self.response.generation_id
-
-    @property
-    def usage(self) -> ApiMetaBilledUnits | None:
-        """Returns the usage of the response."""
-        if self.response.meta:
-            return self.response.meta.billed_units
-        return None
-
-    @property
-    def input_tokens(self) -> float | None:
-        """Returns the number of input tokens."""
-        if self.usage:
-            return self.usage.input_tokens
-        return None
-
-    @property
-    def output_tokens(self) -> float | None:
-        """Returns the number of output tokens."""
-        if self.usage:
-            return self.usage.output_tokens
-        return None
-
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the response."""
-        return calculate_cost(self.input_tokens, self.output_tokens, self.model)
-
-    @computed_field
-    @property
-    def message_param(self) -> ChatMessage:
-        """Returns the assistant's response as a message parameter."""
-        return ChatMessage(
-            message=self.response.text,
-            tool_calls=self.response.tool_calls,
-            role="assistant",  # type: ignore
-        )
-
-    @computed_field
-    @property
-    def tools(self) -> list[CohereTool] | None:
-        """Returns the tools for the 0th choice message.
-
-        Raises:
-            ValidationError: if a tool call doesn't match the tool's schema.
-        """
-        if not self.tool_types or not self.response.tool_calls:
-            return None
-        extracted_tools: list[CohereTool] = []
-        for tool_call in self.response.tool_calls:
-            for tool_type in self.tool_types:
-                if tool_call.name == tool_type._name():
-                    extracted_tools.append(tool_type.from_tool_call(tool_call))
-                    break
-        return extracted_tools
-
-    @computed_field
-    @property
-    def tool(self) -> CohereTool | None:
-        """Returns the 0th tool for the 0th choice message.
-
-        Raises:
-            ValidationError: if the tool call doesn't match the tool's schema.
-        """
-        tools = self.tools
-        if tools:
-            return tools[0]
-        return None
-
-    @classmethod
-    def tool_message_params(
-        cls,
-        tools_and_outputs: list[tuple[CohereTool, str]],
-    ) -> list[ToolResult]:
-        """Returns the tool message parameters for tool call results.
-
-        Args:
-            tools_and_outputs: The list of tools and their outputs from which the tool
-                message parameters should be constructed.
-
-        Returns:
-            The list of constructed `ToolResult` parameters.
-        """
-        return [
-            ToolResult(
-                call=tool.tool_call,
-                outputs=[{"output": output}],
-            )
-            for tool, output in tools_and_outputs
-        ]

mirascope/core/cohere/call_response_chunk.py

@@ -1,101 +0,0 @@
-"""This module contains the `CohereCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from cohere import StreamedChatResponse_StreamEnd, StreamedChatResponse_StreamStart
-from cohere.types import (
-    ApiMetaBilledUnits,
-    ChatStreamEndEventFinishReason,
-    StreamedChatResponse,
-    StreamedChatResponse_TextGeneration,
-)
-from pydantic import SkipValidation
-
-from ..base import BaseCallResponseChunk
-
-
-class CohereCallResponseChunk(
-    BaseCallResponseChunk[
-        SkipValidation[StreamedChatResponse], ChatStreamEndEventFinishReason
-    ]
-):
-    """A convenience wrapper around the Cohere `ChatCompletionChunk` streamed chunks.
-
-    When calling the Cohere API using a function decorated with `cohere_call` and
-    `stream` set to `True`, the stream will contain `CohereResponseChunk` instances with
-    properties that allow for more convenient access to commonly used attributes.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.cohere import cohere_call
-
-
-    @cohere_call("command-r-plus", stream=True)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # response is an `CohereStream`
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    @property
-    def content(self) -> str:
-        """Returns the content for the 0th choice delta."""
-        if isinstance(self.chunk, StreamedChatResponse_TextGeneration):
-            return self.chunk.text
-        return ""
-
-    @property
-    def finish_reasons(self) -> list[ChatStreamEndEventFinishReason] | None:
-        """Returns the finish reasons of the response."""
-        if isinstance(self.chunk, StreamedChatResponse_StreamEnd):
-            return [self.chunk.finish_reason]
-        return None
-
-    @property
-    def model(self) -> str | None:
-        """Returns the name of the response model.
-
-        Cohere does not return model, so we return None
-        """
-        return None
-
-    @property
-    def id(self) -> str | None:
-        """Returns the id of the response."""
-        if isinstance(self.chunk, StreamedChatResponse_StreamStart):
-            return self.chunk.generation_id
-        elif isinstance(self.chunk, StreamedChatResponse_StreamEnd):
-            return self.chunk.response.generation_id
-        return None
-
-    @property
-    def usage(self) -> ApiMetaBilledUnits | None:
-        """Returns the usage of the response."""
-        if (
-            isinstance(self.chunk, StreamedChatResponse_StreamEnd)
-            and self.chunk.response.meta
-        ):
-            return self.chunk.response.meta.billed_units
-        return None
-
-    @property
-    def input_tokens(self) -> float | None:
-        """Returns the number of input tokens."""
-        if self.usage:
-            return self.usage.input_tokens
-        return None
-
-    @property
-    def output_tokens(self) -> float | None:
-        """Returns the number of output tokens."""
-        if self.usage:
-            return self.usage.output_tokens
-        return None

mirascope/core/cohere/dynamic_config.py

@@ -1,24 +0,0 @@
-"""This module defines the function return type for functions as LLM calls.
-
-usage docs: learn/dynamic_configuration.md#dynamic-configuration-options
-"""
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import CohereCallParams
-
-CohereDynamicConfig = BaseDynamicConfig[BaseMessageParam, CohereCallParams]
-"""The function return type for functions wrapped with the `cohere_call` decorator.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.cohere import CohereDynamicConfig, cohere_call
-
-
-@cohere_call("command-r-plus")
-@prompt_template("Recommend a {capitalized_genre} book")
-def recommend_book(genre: str) -> CohereDynamicConfig:
-    return {"computed_fields": {"capitalized_genre": genre.capitalize()}}
-```
-"""

mirascope/core/cohere/stream.py

@@ -1,113 +0,0 @@
-"""The `CohereStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from cohere.types import (
-    ApiMeta,
-    ApiMetaBilledUnits,
-    ChatMessage,
-    ChatStreamEndEventFinishReason,
-    NonStreamedChatResponse,
-    ToolCall,
-)
-
-from ..base.stream import BaseStream
-from ._utils import calculate_cost
-from .call_params import CohereCallParams
-from .call_response import CohereCallResponse
-from .call_response_chunk import CohereCallResponseChunk
-from .dynamic_config import CohereDynamicConfig
-from .tool import CohereTool
-
-
-class CohereStream(
-    BaseStream[
-        CohereCallResponse,
-        CohereCallResponseChunk,
-        ChatMessage,
-        ChatMessage,
-        ChatMessage,
-        ChatMessage,
-        CohereTool,
-        CohereDynamicConfig,
-        CohereCallParams,
-        ChatStreamEndEventFinishReason,
-    ]
-):
-    """A class for convenience around streaming Cohere LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.cohere import cohere_call
-
-
-    @cohere_call("command-r-plus", stream=True)
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    stream = recommend_book("fantasy")  # returns `CohereStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "cohere"
-
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(self.input_tokens, self.output_tokens, self.model)
-
-    def _construct_message_param(
-        self, tool_calls: list[ToolCall] | None = None, content: str | None = None
-    ) -> ChatMessage:
-        return ChatMessage(
-            role="assistant",  # type: ignore
-            message=content if content else "",
-            tool_calls=tool_calls,
-        )
-
-    def construct_call_response(self) -> CohereCallResponse:
-        """Constructs the call response from a consumed CohereStream.
-
-        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."
-            )
-        if not self.input_tokens and not self.output_tokens:
-            meta = None
-        else:
-            meta = ApiMeta(
-                billed_units=ApiMetaBilledUnits(
-                    input_tokens=self.input_tokens, output_tokens=self.output_tokens
-                )
-            )
-        completion = NonStreamedChatResponse(
-            generation_id=self.id,
-            text=self.message_param.message,
-            meta=meta,
-            finish_reason=self.finish_reasons[0] if self.finish_reasons else None,
-        )
-
-        return CohereCallResponse(
-            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,
-        )

mirascope/core/cohere/tool.py

@@ -1,92 +0,0 @@
-"""The `CohereTool` class for easy tool usage with Cohere LLM calls.
-
-usage docs: learn/tools.md#using-tools-with-standard-calls
-"""
-
-from __future__ import annotations
-
-from cohere.types import Tool, ToolCall, ToolParameterDefinitionsValue
-from pydantic import SkipValidation
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool
-
-
-class CohereTool(BaseTool):
-    """A class for defining tools for Cohere LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.cohere import cohere_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @cohere_call("command-r-plus", tools=[format_book])
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `CohereTool` instance
-        print(tool.call())
-    ```
-    """
-
-    tool_call: SkipValidation[SkipJsonSchema[ToolCall]]
-
-    @classmethod
-    def tool_schema(cls) -> Tool:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.cohere import CohereTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = CohereTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Cohere-specific tool schema
-        ```
-        """
-        model_schema = cls.model_tool_schema()
-        parameter_definitions = None
-        if "properties" in model_schema:
-            if "$defs" in model_schema["properties"]:
-                raise ValueError(  # pragma: no cover
-                    "Unfortunately Cohere's chat API cannot handle nested structures "
-                    "with $defs."
-                )
-            parameter_definitions = {
-                prop: ToolParameterDefinitionsValue(
-                    description=prop_schema.get("description", None),
-                    type=prop_schema["type"],
-                    required="required" in model_schema
-                    and prop in model_schema["required"],
-                )
-                for prop, prop_schema in model_schema["properties"].items()
-            }
-        return Tool(
-            name=cls._name(),
-            description=cls._description(),
-            parameter_definitions=parameter_definitions,
-        )
-
-    @classmethod
-    def from_tool_call(cls, tool_call: ToolCall) -> CohereTool:
-        """Constructs an `CohereTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Cohere tool call from which to construct this tool instance.
-        """
-        model_json = {**tool_call.parameters}
-        model_json["tool_call"] = tool_call.dict()
-        return cls.model_validate(model_json)

mirascope/core/gemini/__init__.py

@@ -1,21 +0,0 @@
-"""The Mirascope Gemini Module."""
-
-from ._call import gemini_call
-from ._call import gemini_call as call
-from .call_params import GeminiCallParams
-from .call_response import GeminiCallResponse
-from .call_response_chunk import GeminiCallResponseChunk
-from .dynamic_config import GeminiDynamicConfig
-from .stream import GeminiStream
-from .tool import GeminiTool
-
-__all__ = [
-    "call",
-    "GeminiDynamicConfig",
-    "GeminiCallParams",
-    "GeminiCallResponse",
-    "GeminiCallResponseChunk",
-    "GeminiStream",
-    "GeminiTool",
-    "gemini_call",
-]

mirascope/core/gemini/_call.py

@@ -1,71 +0,0 @@
-"""The `gemini_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 GeminiCallParams
-from .call_response import GeminiCallResponse
-from .call_response_chunk import GeminiCallResponseChunk
-from .dynamic_config import GeminiDynamicConfig
-from .stream import GeminiStream
-from .tool import GeminiTool
-
-gemini_call = call_factory(
-    TCallResponse=GeminiCallResponse,
-    TCallResponseChunk=GeminiCallResponseChunk,
-    TDynamicConfig=GeminiDynamicConfig,
-    TStream=GeminiStream,
-    TToolType=GeminiTool,
-    TCallParams=GeminiCallParams,
-    default_call_params=GeminiCallParams(),
-    setup_call=setup_call,  # type: ignore
-    get_json_output=get_json_output,
-    handle_stream=handle_stream,
-    handle_stream_async=handle_stream_async,
-)
-"""A decorator for calling the Gemini API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Gemini API. It parses
-the docstring 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.gemini import gemini_call
-
-
-@gemini_call("gemini-1.5-flash")
-@prompt_template("Recommend a {genre} book")
-def recommend_book(genre: str):
-    ...
-
-response = recommend_book("fantasy")
-print(response.content)
-```
-
-Args:
-    model (str): The Gemini 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 Gemini API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[GeminiCallResponse | 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 (GeminiCallParams): The `GeminiCallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a Gemini API
-        call.
-"""

mirascope/core/gemini/_utils/__init__.py

@@ -1,16 +0,0 @@
-"""Gemini utilities for decorator factories."""
-
-from ._calculate_cost import calculate_cost
-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__ = [
-    "calculate_cost",
-    "convert_message_params",
-    "get_json_output",
-    "handle_stream",
-    "handle_stream_async",
-    "setup_call",
-]

mirascope/core/gemini/_utils/_calculate_cost.py

@@ -1,8 +0,0 @@
-"""Calculate the cost of a Gemini API call."""
-
-
-def calculate_cost(
-    input_tokens: int | float | None, output_tokens: int | float | None, model: str
-) -> float | None:
-    """Calculate the cost of a Gemini API call."""
-    return None

mirascope/core/gemini/_utils/_convert_message_params.py

@@ -1,74 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ContentsType`"""
-
-import io
-
-import PIL.Image
-from google.generativeai.types import ContentDict
-
-from ...base import BaseMessageParam
-
-
-def convert_message_params(
-    message_params: list[BaseMessageParam | ContentDict],
-) -> list[ContentDict]:
-    converted_message_params = []
-    for message_param in message_params:
-        if not isinstance(message_param, BaseMessageParam):
-            converted_message_params.append(message_param)
-        elif (role := message_param.role) == "system":
-            content = message_param.content
-            if not isinstance(message_param.content, str):
-                raise ValueError(
-                    "System message content must be a single text string."
-                )  # pragma: no cover
-            converted_message_params += [
-                {
-                    "role": "user",
-                    "parts": [message_param.content],
-                },
-                {
-                    "role": "model",
-                    "parts": ["Ok! I will adhere to this system message."],
-                },
-            ]
-        elif isinstance((content := message_param.content), str):
-            converted_message_params.append({"role": "user", "parts": [content]})
-        else:
-            converted_content = []
-            for part in content:
-                if part.type == "text":
-                    converted_content.append(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}. "
-                            "Gemini currently only supports JPEG, PNG, WebP, HEIC, "
-                            "and HEIF images."
-                        )
-                    image = PIL.Image.open(io.BytesIO(part.image))
-                    converted_content.append(image)
-                else:
-                    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}. "
-                            "Gemini currently only supports WAV, MP3, AIFF, AAC, OGG, "
-                            "and FLAC audio file types."
-                        )
-                    converted_content.append(
-                        {"mime_type": part.media_type, "data": part.audio}
-                    )
-            converted_message_params.append({"role": role, "parts": converted_content})
-    return converted_message_params