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

mirascope/core/cohere/call_response.py

@@ -1,205 +0,0 @@
-"""This module contains the `CohereCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from collections.abc import Sequence
-from functools import cached_property
-
-from cohere.types import (
-    ApiMetaBilledUnits,
-    ChatMessage,
-    NonStreamedChatResponse,
-    Tool,
-    ToolResult,
-)
-from pydantic import 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 CohereMessageParamConverter
-from .call_params import CohereCallParams
-from .dynamic_config import AsyncCohereDynamicConfig, CohereDynamicConfig
-from .tool import CohereTool
-
-
-class CohereCallResponse(
-    BaseCallResponse[
-        SkipValidation[NonStreamedChatResponse],
-        CohereTool,
-        SkipValidation[Tool],
-        AsyncCohereDynamicConfig | CohereDynamicConfig,
-        SkipValidation[ChatMessage],
-        CohereCallParams,
-        SkipValidation[ChatMessage],
-        CohereMessageParamConverter,
-    ]
-):
-    """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")
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")  # response is an `CohereCallResponse` instance
-    print(response.content)
-    ```
-    """
-
-    _message_converter: type[CohereMessageParamConverter] = CohereMessageParamConverter
-
-    _provider = "cohere"
-
-    @computed_field
-    @property
-    def content(self) -> str:
-        """Returns the content of the chat completion for the 0th choice."""
-        return self.response.text
-
-    @computed_field
-    @property
-    def finish_reasons(self) -> list[str] | None:
-        """Returns the finish reasons of the response."""
-        return [str(self.response.finish_reason)]
-
-    @computed_field
-    @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
-
-    @computed_field
-    @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
-
-    @computed_field
-    @property
-    def input_tokens(self) -> float | None:
-        """Returns the number of input tokens."""
-        if self.usage:
-            return self.usage.input_tokens
-        return None
-
-    @computed_field
-    @property
-    def cached_tokens(self) -> float | None:
-        """Returns the number of cached tokens."""
-        return None
-
-    @computed_field
-    @property
-    def output_tokens(self) -> float | None:
-        """Returns the number of output tokens."""
-        if self.usage:
-            return self.usage.output_tokens
-        return None
-
-    @computed_field
-    @cached_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",  # pyright: ignore [reportCallIssue]
-        )
-
-    @cached_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
-
-    @cached_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
-    @transform_tool_outputs
-    def tool_message_params(
-        cls,
-        tools_and_outputs: Sequence[tuple[CohereTool, str]],
-    ) -> list[ToolResult]:
-        """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 `ToolResult` parameters.
-        """
-        return [
-            ToolResult(
-                call=tool.tool_call,  # pyright: ignore [reportArgumentType]
-                outputs=[{"output": output}],
-            )
-            for tool, output in tools_and_outputs
-        ]
-
-    @property
-    def common_finish_reasons(self) -> list[FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
-
-    @property
-    def common_message_param(self) -> BaseMessageParam:
-        return CohereMessageParamConverter.from_provider([self.message_param])[0]
-
-    @property
-    def common_user_message_param(self) -> BaseMessageParam | None:
-        if not self.user_message_param:
-            return None
-        return CohereMessageParamConverter.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/cohere/call_response_chunk.py

@@ -1,125 +0,0 @@
-"""This module contains the `CohereCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from typing import cast
-
-from cohere.types import (
-    ApiMetaBilledUnits,
-    ChatStreamEndEventFinishReason,
-    StreamedChatResponse,
-)
-from pydantic import SkipValidation
-
-from ..base import BaseCallResponseChunk, types
-from ..base.types import CostMetadata
-from ._types import (
-    StreamEndStreamedChatResponse,
-    StreamStartStreamedChatResponse,
-    TextGenerationStreamedChatResponse,
-)
-from ._utils._convert_finish_reason_to_common_finish_reasons import (
-    _convert_finish_reasons_to_common_finish_reasons,
-)
-
-
-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)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    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, TextGenerationStreamedChatResponse):
-            return self.chunk.text
-        return ""
-
-    @property
-    def finish_reasons(self) -> list[ChatStreamEndEventFinishReason] | None:
-        """Returns the finish reasons of the response."""
-        if isinstance(self.chunk, StreamEndStreamedChatResponse):
-            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, StreamStartStreamedChatResponse):
-            return self.chunk.generation_id
-        elif isinstance(self.chunk, StreamEndStreamedChatResponse):
-            return self.chunk.response.generation_id
-        return None
-
-    @property
-    def usage(self) -> ApiMetaBilledUnits | None:
-        """Returns the usage of the response."""
-        if (
-            isinstance(self.chunk, StreamEndStreamedChatResponse)
-            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 cached_tokens(self) -> float | None:
-        """Returns the number of cached 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_metadata(self) -> CostMetadata:
-        """Returns the cost metadata."""
-        return super().cost_metadata
-
-    @property
-    def common_finish_reasons(self) -> list[types.FinishReason] | None:
-        return _convert_finish_reasons_to_common_finish_reasons(
-            cast(list[str], self.finish_reasons)
-        )

mirascope/core/cohere/dynamic_config.py

@@ -1,32 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from cohere import (
-    AsyncClient,
-    Client,
-)
-from cohere.types.chat_message import ChatMessage
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import CohereCallParams
-
-AsyncCohereDynamicConfig = BaseDynamicConfig[
-    ChatMessage | BaseMessageParam, CohereCallParams, AsyncClient
-]
-CohereDynamicConfig = BaseDynamicConfig[
-    ChatMessage | BaseMessageParam, CohereCallParams, Client
-]
-"""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,
-    Tool,
-    ToolCall,
-)
-
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from .call_params import CohereCallParams
-from .call_response import CohereCallResponse
-from .call_response_chunk import CohereCallResponseChunk
-from .dynamic_config import AsyncCohereDynamicConfig, CohereDynamicConfig
-from .tool import CohereTool
-
-
-class CohereStream(
-    BaseStream[
-        CohereCallResponse,
-        CohereCallResponseChunk,
-        ChatMessage,
-        ChatMessage,
-        ChatMessage,
-        ChatMessage,
-        CohereTool,
-        Tool,
-        AsyncCohereDynamicConfig | 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)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    stream = recommend_book("fantasy")  # returns `CohereStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "cohere"
-
-    def _construct_message_param(
-        self, tool_calls: list[ToolCall] | None = None, content: str | None = None
-    ) -> ChatMessage:
-        return ChatMessage(
-            role="assistant",  # pyright: ignore [reportCallIssue]
-            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,
-        )
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        return super().cost_metadata

mirascope/core/cohere/tool.py

@@ -1,93 +0,0 @@
-"""The `CohereTool` class for easy tool usage with Cohere LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-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])
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    response = recommend_book("fantasy")
-    if tool := response.tool:  # returns an `CohereTool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "cohere"
-
-    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_json_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/costs/__init__.py

@@ -1,5 +0,0 @@
-"""Cost calculation module for LLM API calls."""
-
-from .calculate_cost import calculate_cost
-
-__all__ = ["calculate_cost"]