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

mirascope/core/cohere/__init__.py

@@ -1,30 +0,0 @@
-"""The Mirascope Cohere Module."""
-
-from typing import TypeAlias
-
-from cohere.types import ChatMessage, ToolResult
-
-from ..base import BaseMessageParam
-from ._call import cohere_call
-from ._call import cohere_call as call
-from .call_params import CohereCallParams
-from .call_response import CohereCallResponse
-from .call_response_chunk import CohereCallResponseChunk
-from .dynamic_config import AsyncCohereDynamicConfig, CohereDynamicConfig
-from .stream import CohereStream
-from .tool import CohereTool
-
-CohereMessageParam: TypeAlias = ChatMessage | ToolResult | BaseMessageParam
-
-__all__ = [
-    "AsyncCohereDynamicConfig",
-    "CohereCallParams",
-    "CohereCallResponse",
-    "CohereCallResponseChunk",
-    "CohereDynamicConfig",
-    "CohereMessageParam",
-    "CohereStream",
-    "CohereTool",
-    "call",
-    "cohere_call",
-]

mirascope/core/cohere/_call.py

@@ -1,67 +0,0 @@
-"""The `cohere_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 CohereCallParams
-from .call_response import CohereCallResponse
-from .call_response_chunk import CohereCallResponseChunk
-from .stream import CohereStream
-from .tool import CohereTool
-
-cohere_call = call_factory(
-    TCallResponse=CohereCallResponse,
-    TCallResponseChunk=CohereCallResponseChunk,
-    TToolType=CohereTool,
-    TStream=CohereStream,
-    default_call_params=CohereCallParams(),
-    setup_call=setup_call,
-    get_json_output=get_json_output,
-    handle_stream=handle_stream,
-    handle_stream_async=handle_stream_async,
-)
-"""A decorator for calling the Cohere API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Cohere 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.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")
-print(response.content)
-```
-
-Args:
-    model (str): The Cohere 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 Cohere API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[CohereCallResponse | ResponseModelT], Any]): A function for
-        parsing the call response whose value will be returned in place of the original
-        call response.
-    json_mode (bool): Whether to use JSON Mode.
-    client (object): An optional custom client to use in place of the default client.
-    call_params (CohereCallParams): The `CohereCallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a Cohere API
-        call.
-"""

mirascope/core/cohere/_call_kwargs.py

@@ -1,11 +0,0 @@
-"""This module contains the type definition for the Cohere call keyword arguments."""
-
-from cohere.types import Tool
-
-from ..base import BaseCallKwargs
-from .call_params import CohereCallParams
-
-
-class CohereCallKwargs(CohereCallParams, BaseCallKwargs[Tool]):
-    model: str
-    message: str

mirascope/core/cohere/_types.py

@@ -1,20 +0,0 @@
-try:
-    from cohere import StreamEndStreamedChatResponse, StreamStartStreamedChatResponse
-    from cohere.types import (
-        TextGenerationStreamedChatResponse,
-        ToolCallsGenerationStreamedChatResponse,
-    )
-except ImportError:  # pragma: no cover
-    # When cohere version is less than 5.11.0
-    from cohere import (
-        StreamedChatResponse_StreamEnd as StreamEndStreamedChatResponse,  # pyright: ignore [reportAttributeAccessIssue]  # noqa: F401
-    )
-    from cohere import (
-        StreamedChatResponse_StreamStart as StreamStartStreamedChatResponse,  # pyright: ignore [reportAttributeAccessIssue]  # noqa: F401
-    )
-    from cohere.types import (
-        StreamedChatResponse_TextGeneration as TextGenerationStreamedChatResponse,  # pyright: ignore [reportAttributeAccessIssue]  # noqa: F401
-    )
-    from cohere.types import (
-        StreamedChatResponse_ToolCallsGeneration as ToolCallsGenerationStreamedChatResponse,  # pyright: ignore [reportAttributeAccessIssue]  # noqa: F401
-    )

mirascope/core/cohere/_utils/__init__.py

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

@@ -1,26 +0,0 @@
-from typing import cast
-
-from ...base.call_params import CommonCallParams
-from ..call_params import CohereCallParams
-
-COHERE_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "max_tokens",
-    "top_p": "p",
-    "frequency_penalty": "frequency_penalty",
-    "presence_penalty": "presence_penalty",
-    "seed": "seed",
-    "stop": "stop_sequences",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> CohereCallParams:
-    """Convert CommonCallParams to Cohere parameters."""
-    return cast(
-        CohereCallParams,
-        {
-            COHERE_PARAM_MAPPING[key]: [value] if isinstance(value, str) else value
-            for key, value in common_params.items()
-            if key in COHERE_PARAM_MAPPING and COHERE_PARAM_MAPPING[key] is not None
-        },
-    )

mirascope/core/cohere/_utils/_convert_finish_reason_to_common_finish_reasons.py

@@ -1,24 +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] = {
-    "COMPLETE": "stop",
-    "STOP_SEQUENCE": "stop",
-    "ERROR": "stop",
-    "ERROR_TOXIC": "content_filter",
-    "ERROR_LIMIT": "length",
-    "USER_CANCEL": "stop",
-    "MAX_TOKENS": "length",
-}
-
-
-def _convert_finish_reasons_to_common_finish_reasons(
-    finish_reasons: list[str] | None,
-) -> list[FinishReason] | None:
-    """Provider-agnostic finish reasons."""
-    return _convert_finish_reasons_to_common_finish_reasons_from_mapping(
-        finish_reasons, _FinishReasonMapping
-    )

mirascope/core/cohere/_utils/_convert_message_params.py

@@ -1,32 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ChatCompletionMessageParam`"""
-
-from cohere.types import ChatMessage
-
-from ...base import BaseMessageParam
-
-
-def convert_message_params(
-    message_params: list[BaseMessageParam | ChatMessage],
-) -> list[ChatMessage]:
-    converted_message_params = []
-    for message_param in message_params:
-        if isinstance(message_param, ChatMessage):
-            converted_message_params.append(message_param)
-        elif isinstance(content := message_param.content, str):
-            converted_message_params.append(
-                ChatMessage(
-                    role=message_param.role.upper(),  # pyright: ignore [reportCallIssue]
-                    message=content,
-                )
-            )
-        else:
-            # TODO: Add support tool_result
-            if len(content) != 1 or content[0].type != "text":
-                raise ValueError("Cohere currently only supports text parts.")
-            converted_message_params.append(
-                ChatMessage(
-                    role=message_param.role.upper(),  # pyright: ignore [reportCallIssue]
-                    message=content[0].text,
-                )
-            )
-    return converted_message_params

mirascope/core/cohere/_utils/_get_json_output.py

@@ -1,30 +0,0 @@
-"""Get the JSON output from a completion response."""
-
-import json
-
-from .._types import ToolCallsGenerationStreamedChatResponse
-from ..call_response import CohereCallResponse
-from ..call_response_chunk import CohereCallResponseChunk
-
-
-def get_json_output(
-    response: CohereCallResponse | CohereCallResponseChunk, json_mode: bool
-) -> str:
-    """Get the JSON output from a completion response."""
-    if isinstance(response, CohereCallResponse):
-        if json_mode and response.content:
-            return response.content
-        elif response.response.tool_calls:
-            return json.dumps(response.response.tool_calls[0].parameters)
-        raise ValueError("No tool call or JSON object found in response.")
-    else:
-        # raise ValueError("Cohere does not support structured streaming... :(")
-        if json_mode:
-            return response.content
-        elif (
-            isinstance(response.chunk, ToolCallsGenerationStreamedChatResponse)
-            and (tool_calls := response.chunk.tool_calls)
-            and (parameters := tool_calls[0].parameters)
-        ):
-            return json.dumps(parameters)
-        return ""

mirascope/core/cohere/_utils/_handle_stream.py

@@ -1,35 +0,0 @@
-"""Handles the stream of completion chunks."""
-
-from collections.abc import AsyncGenerator, Generator
-
-from cohere.types import StreamedChatResponse
-
-from ..call_response_chunk import CohereCallResponseChunk
-from ..tool import CohereTool
-
-
-def handle_stream(
-    stream: Generator[StreamedChatResponse, None, None],
-    tool_types: list[type[CohereTool]] | None = None,
-    partial_tools: bool = False,
-) -> Generator[tuple[CohereCallResponseChunk, None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed.
-
-    Note: cohere does not currently support streaming tools.
-    """
-    for chunk in stream:
-        yield CohereCallResponseChunk(chunk=chunk), None
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[StreamedChatResponse, None],
-    tool_types: list[type[CohereTool]] | None = None,
-    partial_tools: bool = False,
-) -> AsyncGenerator[tuple[CohereCallResponseChunk, None], None]:
-    """
-    Async iterator over the stream and constructs tools as they are streamed.
-
-    Note: cohere does not currently support streaming tools.
-    """
-    async for chunk in stream:
-        yield CohereCallResponseChunk(chunk=chunk), None

mirascope/core/cohere/_utils/_message_param_converter.py

@@ -1,54 +0,0 @@
-from typing import cast
-
-from cohere.types import ChatMessage
-
-from mirascope.core import BaseMessageParam
-from mirascope.core.base import TextPart, ToolCallPart
-from mirascope.core.base._utils._base_message_param_converter import (
-    BaseMessageParamConverter,
-)
-from mirascope.core.cohere._utils import convert_message_params
-
-
-class CohereMessageParamConverter(BaseMessageParamConverter):
-    """Converts between Cohere `ChatMessage` and Mirascope `BaseMessageParam`."""
-
-    @staticmethod
-    def to_provider(message_params: list[BaseMessageParam]) -> list[ChatMessage]:
-        """
-        Convert from Mirascope `BaseMessageParam` to Cohere's `ChatMessage`.
-        """
-        return convert_message_params(
-            cast(list[BaseMessageParam | ChatMessage], message_params)
-        )
-
-    @staticmethod
-    def from_provider(message_params: list[ChatMessage]) -> list[BaseMessageParam]:
-        """
-        Convert from Cohere's `ChatMessage` to Mirascope `BaseMessageParam`.
-        """
-        converted = []
-        for message_param in message_params:
-            role = getattr(message_param, "role", "assistant")
-            if not message_param.tool_calls:
-                converted.append(
-                    BaseMessageParam(role=role, content=message_param.message)
-                )
-                continue
-
-            converted_content = []
-
-            if message_param.message:
-                converted_content.append(
-                    TextPart(type="text", text=message_param.message)
-                )
-
-            for tool_call in message_param.tool_calls:
-                converted_content.append(
-                    ToolCallPart(
-                        type="tool_call", name=tool_call.name, args=tool_call.parameters
-                    )
-                )
-
-            converted.append(BaseMessageParam(role=role, content=converted_content))
-        return converted

mirascope/core/cohere/_utils/_setup_call.py

@@ -1,150 +0,0 @@
-"""This module contains the setup_call function for Cohere tools."""
-
-import inspect
-from collections.abc import (
-    Awaitable,
-    Callable,
-)
-from typing import (
-    Any,
-    cast,
-    overload,
-)
-
-from cohere import (
-    AsyncClient,
-    Client,
-    NonStreamedChatResponse,
-)
-from cohere.types import ChatMessage, StreamedChatResponse
-from pydantic import BaseModel
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ...base._utils import (
-    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 CohereCallKwargs
-from ..call_params import CohereCallParams
-from ..dynamic_config import AsyncCohereDynamicConfig, CohereDynamicConfig
-from ..tool import CohereTool
-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: AsyncClient | None,
-    fn: Callable[..., Awaitable[AsyncCohereDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: AsyncCohereDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: CohereCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[NonStreamedChatResponse, StreamedChatResponse],
-    str,
-    list[ChatMessage],
-    list[type[CohereTool]] | None,
-    CohereCallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: Client | None,
-    fn: Callable[..., CohereDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: CohereDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: CohereCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[NonStreamedChatResponse, StreamedChatResponse],
-    str,
-    list[ChatMessage],
-    list[type[CohereTool]] | None,
-    CohereCallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: Client | AsyncClient | None,
-    fn: Callable[..., CohereDynamicConfig | Awaitable[AsyncCohereDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: CohereDynamicConfig | AsyncCohereDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: CohereCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[NonStreamedChatResponse, StreamedChatResponse]
-    | AsyncCreateFn[NonStreamedChatResponse, StreamedChatResponse],
-    str | None,
-    list[ChatMessage],
-    list[type[CohereTool]] | None,
-    CohereCallKwargs,
-]:
-    prompt_template, messages, tool_types, call_kwargs = _utils.setup_call(
-        fn,
-        fn_args,
-        dynamic_config,
-        tools,
-        CohereTool,
-        call_params,
-        convert_common_call_params,
-    )
-    call_kwargs = cast(CohereCallKwargs, call_kwargs)
-    messages = cast(list[BaseMessageParam | ChatMessage], messages)
-    messages = convert_message_params(messages)
-
-    preamble = ""
-    if "preamble" in call_kwargs and call_kwargs["preamble"] is not None:
-        preamble = call_kwargs.pop("preamble", "") or ""
-    if messages[0].role == "SYSTEM":  # pyright: ignore [reportAttributeAccessIssue]
-        if preamble:
-            preamble += "\n\n"
-        preamble += messages.pop(0).message
-    if preamble:
-        call_kwargs["preamble"] = preamble
-    if len(messages) > 1:
-        call_kwargs["chat_history"] = messages[:-1]
-    if json_mode:
-        # Cannot mutate ChatMessage in place
-        messages[-1] = ChatMessage(
-            role=messages[-1].role,  # pyright: ignore [reportCallIssue, reportAttributeAccessIssue]
-            message=messages[-1].message + _utils.json_mode_content(response_model),
-            tool_calls=messages[-1].tool_calls,
-        )
-    elif response_model:
-        assert tool_types, "At least one tool must be provided for extraction."
-    call_kwargs |= {
-        "model": model,
-        "message": messages[-1].message,
-    }
-
-    if client is None:
-        client = AsyncClient() if inspect.iscoroutinefunction(fn) else Client()
-
-    create_or_stream = (
-        get_async_create_fn(client.chat, client.chat_stream)
-        if isinstance(client, AsyncClient)
-        else get_create_fn(client.chat, client.chat_stream)
-    )
-
-    return create_or_stream, prompt_template, messages, tool_types, call_kwargs

mirascope/core/cohere/call_params.py

@@ -1,62 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-
-from cohere.types import (
-    ChatConnector,
-    ChatDocument,
-    ChatMessage,
-    ChatRequestPromptTruncation,
-    ToolResult,
-)
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-
-class CohereCallParams(BaseCallParams):
-    """The parameters to use when calling the Cohere API.
-
-    [Cohere API Reference](https://docs.cohere.com/reference/chat)
-
-    Attributes:
-        chat_history: ...
-        connectors: ...
-        conversation_id: ...
-        documents: ...
-        frequency_penalty: ...
-        k: ...
-        max_input_tokens: ...
-        max_tokens: ...
-        p: ...
-        preamble: ...
-        presence_penalty: ...
-        prompt_truncation: ...
-        raw_prompting: ...
-        search_queries_only: ...
-        seed: ...
-        stop_sequences: ...
-        temperature: ...
-        tool_results: ...
-    """
-
-    chat_history: NotRequired[Sequence[ChatMessage] | None]
-    connectors: NotRequired[Sequence[ChatConnector] | None]
-    conversation_id: NotRequired[str | None]
-    documents: NotRequired[Sequence[ChatDocument] | None]
-    frequency_penalty: NotRequired[float | None]
-    k: NotRequired[int | None]
-    max_input_tokens: NotRequired[int | None]
-    max_tokens: NotRequired[int | None]
-    p: NotRequired[float | None]
-    preamble: NotRequired[str | None]
-    presence_penalty: NotRequired[float | None]
-    prompt_truncation: NotRequired[ChatRequestPromptTruncation | None]
-    raw_prompting: NotRequired[bool | None]
-    search_queries_only: NotRequired[bool | None]
-    seed: NotRequired[int | None]
-    stop_sequences: NotRequired[Sequence[str] | None]
-    temperature: NotRequired[float | None]
-    tool_results: NotRequired[Sequence[ToolResult] | None]