mirascope 1.25.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

mirascope/core/groq/tool.py

@@ -1,80 +0,0 @@
-"""The `GroqTool` class for easy tool usage with Groq LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-import jiter
-from groq.types.chat import (
-    ChatCompletionMessageToolCall,
-    ChatCompletionToolParam,
-)
-from groq.types.shared_params import FunctionDefinition
-from pydantic.json_schema import SkipJsonSchema
-
-from ..base import BaseTool
-
-
-class GroqTool(BaseTool):
-    """A class for defining tools for Groq LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.groq import groq_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @groq_call("llama-3.1-8b-instant", 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 `GroqTool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "groq"
-
-    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.groq import GroqTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = GroqTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Groq-specific tool schema
-        ```
-        """
-        fn = FunctionDefinition(name=cls._name(), description=cls._description())
-        model_schema = cls.model_json_schema()
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema
-        return ChatCompletionToolParam(function=fn, type="function")
-
-    @classmethod
-    def from_tool_call(cls, tool_call: ChatCompletionMessageToolCall) -> GroqTool:
-        """Constructs an `GroqTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Groq 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/litellm/__init__.py

@@ -1,28 +0,0 @@
-"""The Mirascope LiteLLM Module."""
-
-from typing import TypeAlias
-
-from ..openai import OpenAIMessageParam
-from ._call import litellm_call
-from ._call import litellm_call as call
-from .call_params import LiteLLMCallParams
-from .call_response import LiteLLMCallResponse
-from .call_response_chunk import LiteLLMCallResponseChunk
-from .dynamic_config import AsyncLiteLLMDynamicConfig, LiteLLMDynamicConfig
-from .stream import LiteLLMStream
-from .tool import LiteLLMTool
-
-LiteLLMMessageParam: TypeAlias = OpenAIMessageParam
-
-__all__ = [
-    "AsyncLiteLLMDynamicConfig",
-    "LiteLLMCallParams",
-    "LiteLLMCallResponse",
-    "LiteLLMCallResponseChunk",
-    "LiteLLMDynamicConfig",
-    "LiteLLMMessageParam",
-    "LiteLLMStream",
-    "LiteLLMTool",
-    "call",
-    "litellm_call",
-]

mirascope/core/litellm/_call.py

@@ -1,67 +0,0 @@
-"""The `litellm_call` decorator for functions as LLM calls."""
-
-from ..base import call_factory
-from ..openai._utils import (
-    get_json_output,
-    handle_stream,
-    handle_stream_async,
-)
-from ._utils import setup_call
-from .call_params import LiteLLMCallParams
-from .call_response import LiteLLMCallResponse
-from .call_response_chunk import LiteLLMCallResponseChunk
-from .stream import LiteLLMStream
-from .tool import LiteLLMTool
-
-litellm_call = call_factory(
-    TCallResponse=LiteLLMCallResponse,
-    TCallResponseChunk=LiteLLMCallResponseChunk,
-    TToolType=LiteLLMTool,
-    TStream=LiteLLMStream,
-    default_call_params=LiteLLMCallParams(),
-    setup_call=setup_call,  # pyright: ignore [reportArgumentType]
-    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 LiteLLM API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the LiteLLM 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.litellm import litellm_call
-
-
-@litellm_call("gpt-4o-mini")
-def recommend_book(genre: str) -> str:
-    return f"Recommend a {genre} book"
-
-response = recommend_book("fantasy")
-print(response.content)
-```
-
-Args:
-    model (str): The 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 API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[OpenAICallResponse | 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 (None): LiteLLM does not support a custom client.
-    call_params (OpenAICallParams): The `OpenAICallParams` call parameters to use in the
-        API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a LiteLLM
-        routed LLM API call.
-"""

mirascope/core/litellm/_utils/__init__.py

@@ -1,5 +0,0 @@
-"""LiteLLM utilities for decorator factories."""
-
-from ._setup_call import setup_call
-
-__all__ = ["setup_call"]

mirascope/core/litellm/_utils/_setup_call.py

@@ -1,109 +0,0 @@
-"""This module contains the setup_call function for OpenAI tools."""
-
-from collections.abc import Awaitable, Callable
-from typing import Any, TypeAlias, cast, overload
-
-from litellm import acompletion, completion
-from openai import OpenAI
-from openai.types.chat import ChatCompletion, ChatCompletionMessageParam
-from pydantic import BaseModel
-
-from ...base import BaseTool
-from ...base._utils import AsyncCreateFn, CreateFn, fn_is_async
-from ...base.call_params import CommonCallParams
-from ...base.stream_config import StreamConfig
-from ...openai import (
-    AsyncOpenAIDynamicConfig,
-    OpenAICallParams,
-    OpenAIDynamicConfig,
-    OpenAITool,
-)
-from ...openai._call_kwargs import OpenAICallKwargs
-from ...openai._utils import setup_call as setup_call_openai
-
-# Note: MyPy doesn't like `client: ...` so we use these aliases instead.
-_AsyncLiteLLMClient: TypeAlias = Any
-_SyncLiteLLMClient: TypeAlias = Any
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: _AsyncLiteLLMClient | None,
-    fn: Callable[..., Awaitable[AsyncOpenAIDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: AsyncOpenAIDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: OpenAICallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[ChatCompletion, ChatCompletion],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    OpenAICallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: _SyncLiteLLMClient | None,
-    fn: Callable[..., OpenAIDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: OpenAIDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: OpenAICallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletion, ChatCompletion],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    OpenAICallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: None,
-    fn: Callable[..., OpenAIDynamicConfig | Awaitable[AsyncOpenAIDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: OpenAIDynamicConfig | AsyncOpenAIDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: OpenAICallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletion, ChatCompletion]
-    | AsyncCreateFn[ChatCompletion, ChatCompletion],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    OpenAICallKwargs,
-]:
-    _, prompt_template, messages, tool_types, call_kwargs = setup_call_openai(
-        model=model,  # pyright: ignore [reportCallIssue]
-        client=OpenAI(api_key="NOT_USED"),
-        fn=fn,  # pyright: ignore [reportArgumentType]
-        fn_args=fn_args,  # pyright: ignore [reportArgumentType]
-        dynamic_config=dynamic_config,
-        tools=tools,
-        json_mode=json_mode,
-        call_params=call_params,
-        response_model=response_model,
-        stream=stream,
-    )
-    create = cast(
-        Callable[..., ChatCompletion] | Callable[..., Awaitable[ChatCompletion]],
-        acompletion if fn_is_async(fn) else completion,
-    )
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/litellm/call_params.py

@@ -1,10 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from ..openai import OpenAICallParams
-
-
-class LiteLLMCallParams(OpenAICallParams):
-    """A simple wrapper around `OpenAICallParams.`
-
-    Since LiteLLM uses the OpenAI spec, we change nothing here.
-    """

mirascope/core/litellm/call_response.py

@@ -1,24 +0,0 @@
-"""This module contains the `LiteLLMCallResponse` class.
-
-usage docs: learn/calls.md#handling-responses
-"""
-
-from pydantic import computed_field
-
-from ..base.types import CostMetadata
-from ..openai import OpenAICallResponse
-
-
-class LiteLLMCallResponse(OpenAICallResponse):
-    """A simpler wrapper around `OpenAICallResponse`.
-
-    Everything is the same except the `cost` property, which has been updated to use
-    LiteLLM's cost calculations so that cost tracking works for non-OpenAI models.
-    """
-
-    _provider = "litellm"
-
-    @computed_field
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        return CostMetadata(cost=self.response._hidden_params["response_cost"])  # pyright: ignore [reportAttributeAccessIssue]

mirascope/core/litellm/call_response_chunk.py

@@ -1,14 +0,0 @@
-"""This module contains the `LiteLLMCallResponseChunk` class.
-
-usage docs: learn/streams.md#handling-streamed-responses
-"""
-
-from ..openai import OpenAICallResponseChunk
-
-
-class LiteLLMCallResponseChunk(OpenAICallResponseChunk):
-    """A simpler wrapper around `OpenAICallResponse`.
-
-    Everything is the same except the `cost` property, which has been updated to use
-    LiteLLM's cost calculations so that cost tracking works for non-OpenAI models.
-    """

mirascope/core/litellm/dynamic_config.py

@@ -1,8 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from typing import TypeAlias
-
-from ..openai import AsyncOpenAIDynamicConfig, OpenAIDynamicConfig
-
-AsyncLiteLLMDynamicConfig: TypeAlias = AsyncOpenAIDynamicConfig
-LiteLLMDynamicConfig: TypeAlias = OpenAIDynamicConfig

mirascope/core/litellm/stream.py

@@ -1,86 +0,0 @@
-"""The `LiteLLMStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from collections.abc import AsyncGenerator, Generator
-
-from litellm import Choices, Message
-from litellm.cost_calculator import completion_cost
-from litellm.types.utils import ModelResponse
-
-from ..base.types import CostMetadata
-from ..openai import OpenAIStream, OpenAITool
-from .call_response import LiteLLMCallResponse
-from .call_response_chunk import LiteLLMCallResponseChunk
-
-
-class LiteLLMStream(OpenAIStream):
-    """A simple wrapper around `OpenAIStream`.
-
-    Everything is the same except updates to the `construct_call_response` method and
-    the `cost` property so that cost is properly calculated using LiteLLM's cost
-    calculation method. This ensures cost calculation works for non-OpenAI models.
-    """
-
-    _provider = "litellm"
-
-    def __iter__(
-        self,
-    ) -> Generator[tuple[LiteLLMCallResponseChunk, OpenAITool | None], None, None]:
-        yield from super().__iter__()  # pyright: ignore [reportReturnType]
-
-    def __aiter__(
-        self,
-    ) -> AsyncGenerator[tuple[LiteLLMCallResponseChunk, OpenAITool | None], None]:
-        return super().__aiter__()  # pyright: ignore [reportReturnType] # pragma: no cover
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Returns metadata needed for cost calculation."""
-        response = self.construct_call_response()
-        return CostMetadata(
-            cost=response.cost,
-        )
-
-    def construct_call_response(self) -> LiteLLMCallResponse:
-        openai_call_response = super().construct_call_response()
-        openai_response = openai_call_response.response
-        model_response = ModelResponse(
-            id=openai_response.id,
-            choices=[
-                Choices(
-                    finish_reason=choice.finish_reason,
-                    index=choice.index,
-                    message=Message(**choice.message.model_dump()),
-                    logprobs=choice.logprobs,
-                )
-                for choice in openai_response.choices
-            ],
-            created=openai_response.created,
-            model=openai_response.model,
-            object=openai_response.object,
-            system_fingerprint=openai_response.system_fingerprint,
-            usage=openai_response.usage.model_dump() if openai_response.usage else None,
-        )
-        model_response._hidden_params["response_cost"] = completion_cost(
-            model=self.model,
-            messages=openai_call_response.messages,
-            completion=openai_call_response.content,
-        )
-        response = LiteLLMCallResponse(
-            metadata=openai_call_response.metadata,
-            response=model_response,  # pyright: ignore [reportArgumentType]
-            tool_types=openai_call_response.tool_types,
-            prompt_template=openai_call_response.prompt_template,
-            fn_args=openai_call_response.fn_args,
-            dynamic_config=openai_call_response.dynamic_config,
-            messages=openai_call_response.messages,
-            call_params=openai_call_response.call_params,
-            call_kwargs=openai_call_response.call_kwargs,
-            user_message_param=openai_call_response.user_message_param,
-            start_time=openai_call_response.start_time,
-            end_time=openai_call_response.end_time,
-        )
-        response._model = self.model
-        return response

mirascope/core/litellm/tool.py

@@ -1,13 +0,0 @@
-"""The `LiteLLMTool` class for easy tool usage with LiteLLM LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from ..openai import OpenAITool
-
-
-class LiteLLMTool(OpenAITool):
-    """A simple wrapper around `OpenAITool`.
-
-    Since LiteLLM uses the OpenAI spec, we change nothing here.
-    """

mirascope/core/mistral/__init__.py

@@ -1,36 +0,0 @@
-"""The Mirascope Mistral Module."""
-
-from typing import TypeAlias
-
-from mistralai.models import (
-    AssistantMessage,
-    SystemMessage,
-    ToolMessage,
-    UserMessage,
-)
-
-from ..base import BaseMessageParam
-from ._call import mistral_call
-from ._call import mistral_call as call
-from .call_params import MistralCallParams
-from .call_response import MistralCallResponse
-from .call_response_chunk import MistralCallResponseChunk
-from .dynamic_config import MistralDynamicConfig
-from .stream import MistralStream
-from .tool import MistralTool
-
-MistralMessageParam: TypeAlias = (
-    AssistantMessage | SystemMessage | ToolMessage | UserMessage | BaseMessageParam
-)
-
-__all__ = [
-    "MistralCallParams",
-    "MistralCallResponse",
-    "MistralCallResponseChunk",
-    "MistralDynamicConfig",
-    "MistralMessageParam",
-    "MistralStream",
-    "MistralTool",
-    "call",
-    "mistral_call",
-]

mirascope/core/mistral/_call.py

@@ -1,65 +0,0 @@
-"""The `mistral_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 MistralCallParams
-from .call_response import MistralCallResponse
-from .call_response_chunk import MistralCallResponseChunk
-from .stream import MistralStream
-from .tool import MistralTool
-
-mistral_call = call_factory(
-    TCallResponse=MistralCallResponse,
-    TCallResponseChunk=MistralCallResponseChunk,
-    TToolType=MistralTool,
-    TStream=MistralStream,
-    default_call_params=MistralCallParams(),
-    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 Mistral API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Mistral 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.mistral import mistral_call
-
-
-@mistral_call("mistral-large-latest")
-def recommend_book(genre: str) -> str:
-    return f"Recommend a {genre} book"
-
-response = recommend_book("fantasy")
-print(response.content)
-```
-
-Args:
-    model (str): The Mistral 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 Mistral API call.
-    response_model (BaseModel | BaseType): The response model into which the response should be structured.
-    output_parser (Callable[[MistralCallResponse | 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 (MistralCallParams): The `MistralCallParams` call parameters to use in
-        the API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into a Mistral API
-        call.
-"""

mirascope/core/mistral/_call_kwargs.py

@@ -1,19 +0,0 @@
-"""This module contains the type definition for the Mistral call keyword arguments."""
-
-from collections.abc import Sequence
-from typing import Any
-
-from mistralai.models import (
-    AssistantMessage,
-    SystemMessage,
-    ToolMessage,
-    UserMessage,
-)
-
-from ..base import BaseCallKwargs
-from .call_params import MistralCallParams
-
-
-class MistralCallKwargs(MistralCallParams, BaseCallKwargs[dict[str, Any]]):
-    model: str
-    messages: Sequence[AssistantMessage | SystemMessage | ToolMessage | UserMessage]

mirascope/core/mistral/_utils/__init__.py

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

@@ -1,24 +0,0 @@
-from typing import cast
-
-from ...base.call_params import CommonCallParams
-from ..call_params import MistralCallParams
-
-MISTRAL_PARAM_MAPPING = {
-    "temperature": "temperature",
-    "max_tokens": "max_tokens",
-    "top_p": "top_p",
-    "seed": "random_seed",
-    "stop": "stop",
-}
-
-
-def convert_common_call_params(common_params: CommonCallParams) -> MistralCallParams:
-    """Convert CommonCallParams to Mistral parameters."""
-    return cast(
-        MistralCallParams,
-        {
-            MISTRAL_PARAM_MAPPING[key]: value
-            for key, value in common_params.items()
-            if key in MISTRAL_PARAM_MAPPING and value is not None
-        },
-    )

mirascope/core/mistral/_utils/_convert_finish_reason_to_common_finish_reasons.py

@@ -1,22 +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] = {
-    "stop": "stop",
-    "length": "length",
-    "model_length": "length",
-    "error": "stop",
-    "tool_calls": "tool_calls",
-}
-
-
-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
-    )