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

mirascope/core/vertex/dynamic_config.py

@@ -1,28 +0,0 @@
-"""This module defines the function return type for functions as LLM calls."""
-
-from vertexai.generative_models import (
-    Content,
-    GenerativeModel,
-)
-
-from ..base import BaseDynamicConfig, BaseMessageParam
-from .call_params import VertexCallParams
-
-VertexDynamicConfig = BaseDynamicConfig[
-    Content | BaseMessageParam, VertexCallParams, GenerativeModel
-]
-"""The function return type for functions wrapped with the `vertex_call` decorator.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.vertex import VertexDynamicConfig, vertex_call
-
-
-@vertex_call("gemini-1.5-flash")
-@prompt_template("Recommend a {capitalized_genre} book")
-def recommend_book(genre: str) -> VertexDynamicConfig:
-    return {"computed_fields": {"capitalized_genre": genre.capitalize()}}
-```
-"""

mirascope/core/vertex/stream.py

@@ -1,119 +0,0 @@
-"""The `VertexStream` class for convenience around streaming LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from typing import cast
-
-from google.cloud.aiplatform_v1beta1.types import FunctionCall
-from vertexai.generative_models import (
-    Candidate,
-    Content,
-    FinishReason,
-    GenerationResponse,
-    Part,
-    Tool,
-)
-
-from ..base.stream import BaseStream
-from ..base.types import CostMetadata
-from .call_params import VertexCallParams
-from .call_response import VertexCallResponse
-from .call_response_chunk import VertexCallResponseChunk
-from .dynamic_config import VertexDynamicConfig
-from .tool import VertexTool
-
-
-class VertexStream(
-    BaseStream[
-        VertexCallResponse,
-        VertexCallResponseChunk,
-        Content,
-        Content,
-        Content,
-        Content,
-        VertexTool,
-        Tool,
-        VertexDynamicConfig,
-        VertexCallParams,
-        FinishReason,
-    ]
-):
-    """A class for convenience around streaming Vertex LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.vertex import vertex_call
-
-
-    @vertex_call("gemini-1.5-flash", stream=True)
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    stream = recommend_book("fantasy")  # returns `VertexStream` instance
-    for chunk, _ in stream:
-        print(chunk.content, end="", flush=True)
-    ```
-    """
-
-    _provider = "vertex"
-
-    def _construct_message_param(
-        self,
-        tool_calls: list[FunctionCall] | None = None,
-        content: str | None = None,
-    ) -> Content:
-        """Constructs the message parameter for the assistant."""
-        return Content(
-            role="model",
-            parts=cast(list[Part], [Part.from_text(content)] + (tool_calls or [])),  # pyright: ignore [reportArgumentType]
-        )
-
-    def construct_call_response(self) -> VertexCallResponse:
-        """Constructs the call response from a consumed VertexStream.
-
-        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."
-            )
-        response = GenerationResponse.from_dict(
-            {
-                "candidates": [
-                    Candidate.from_dict(
-                        {
-                            "finish_reason": self.finish_reasons[0]
-                            if self.finish_reasons
-                            else FinishReason.STOP,
-                            "content": Content(
-                                role=self.message_param.role,
-                                parts=self.message_param.parts,
-                            ).to_dict(),
-                        }
-                    ).to_dict()
-                ]
-            }
-        )
-        return VertexCallResponse(
-            metadata=self.metadata,
-            response=response,
-            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/vertex/tool.py

@@ -1,101 +0,0 @@
-"""The `VertexTool` class for easy tool usage with Google's Vertex LLM calls.
-
-usage docs: learn/tools.md
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from google.cloud.aiplatform_v1beta1.types import FunctionCall
-from pydantic.json_schema import SkipJsonSchema
-from vertexai.generative_models import FunctionDeclaration, Tool
-
-from ..base import BaseTool
-
-
-class VertexTool(BaseTool):
-    """A class for defining tools for Vertex LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.core import prompt_template
-    from mirascope.core.vertex import vertex_call
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @vertex_call("gemini-1.5-flash", 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 `VertexTool` instance
-        print(tool.call())
-    ```
-    """
-
-    __provider__ = "vertex"
-
-    tool_call: SkipJsonSchema[FunctionCall]
-
-    @classmethod
-    def tool_schema(cls) -> Tool:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.core.vertex import VertexTool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = VertexTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the Vertex-specific tool schema
-        ```
-        """
-        model_schema = cls.model_json_schema()
-        fn: dict[str, Any] = {"name": cls._name(), "description": cls._description()}
-        if model_schema["properties"]:
-            fn["parameters"] = model_schema
-        if model_schema["required"]:
-            fn["parameters"]["required"] = model_schema["required"]
-        if "parameters" in fn:
-            if "$defs" in fn["parameters"]:
-                raise ValueError(
-                    "Unfortunately Google's Vertex API cannot handle nested structures "
-                    "with $defs."
-                )
-
-            def handle_enum_schema(prop_schema: dict[str, Any]) -> dict[str, Any]:
-                if "enum" in prop_schema:
-                    prop_schema["format"] = "enum"
-                return prop_schema
-
-            fn["parameters"]["properties"] = {
-                prop: {
-                    key: value
-                    for key, value in handle_enum_schema(prop_schema).items()
-                    if key != "default"
-                }
-                for prop, prop_schema in fn["parameters"]["properties"].items()
-            }
-        return Tool(function_declarations=[FunctionDeclaration(**fn)])
-
-    @classmethod
-    def from_tool_call(cls, tool_call: FunctionCall) -> VertexTool:
-        """Constructs an `VertexTool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The Vertex tool call from which to construct this tool instance.
-        """
-        model_json = {"tool_call": tool_call}
-        if tool_call.args:
-            model_json |= dict(tool_call.args.items())
-        return cls.model_validate(model_json)

mirascope/core/xai/__init__.py

@@ -1,28 +0,0 @@
-"""The Mirascope xAI Module."""
-
-from typing import TypeAlias
-
-from ..openai import OpenAIMessageParam
-from ._call import xai_call
-from ._call import xai_call as call
-from .call_params import XAICallParams
-from .call_response import XAICallResponse
-from .call_response_chunk import XAICallResponseChunk
-from .dynamic_config import AsyncXAIDynamicConfig, XAIDynamicConfig
-from .stream import XAIStream
-from .tool import XAITool
-
-XAIMessageParam: TypeAlias = OpenAIMessageParam
-
-__all__ = [
-    "AsyncXAIDynamicConfig",
-    "XAICallParams",
-    "XAICallResponse",
-    "XAICallResponseChunk",
-    "XAIDynamicConfig",
-    "XAIMessageParam",
-    "XAIStream",
-    "XAITool",
-    "call",
-    "xai_call",
-]

mirascope/core/xai/_call.py

@@ -1,67 +0,0 @@
-"""The `xai_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 XAICallParams
-from .call_response import XAICallResponse
-from .call_response_chunk import XAICallResponseChunk
-from .stream import XAIStream
-from .tool import XAITool
-
-xai_call = call_factory(
-    TCallResponse=XAICallResponse,
-    TCallResponseChunk=XAICallResponseChunk,
-    TToolType=XAITool,
-    TStream=XAIStream,
-    default_call_params=XAICallParams(),
-    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 xAI API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the xAI 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.xai import xai_call
-
-
-@xai_call("grok-2-latest")
-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): xAI 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 xAI
-        routed LLM API call.
-"""

mirascope/core/xai/_utils/__init__.py

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

mirascope/core/xai/_utils/_setup_call.py

@@ -1,113 +0,0 @@
-"""This module contains the setup_call function for OpenAI tools."""
-
-import os
-from collections.abc import Awaitable, Callable
-from typing import Any, overload
-
-from openai import AsyncOpenAI, OpenAI
-from openai.types.chat import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    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
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: AsyncOpenAI | 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, ChatCompletionChunk],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    OpenAICallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: OpenAI | 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, ChatCompletionChunk],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    OpenAICallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: OpenAI | AsyncOpenAI | None,
-    fn: Callable[..., OpenAIDynamicConfig]
-    | Callable[..., 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, ChatCompletionChunk]
-    | AsyncCreateFn[ChatCompletion, ChatCompletionChunk],
-    str | None,
-    list[ChatCompletionMessageParam],
-    list[type[OpenAITool]] | None,
-    OpenAICallKwargs,
-]:
-    if not client:
-        api_key = os.environ.get("XAI_API_KEY")
-        client = (
-            AsyncOpenAI(api_key=api_key, base_url="https://api.x.ai/v1")
-            if fn_is_async(fn)
-            else OpenAI(api_key=api_key, base_url="https://api.x.ai/v1")
-        )
-    create, prompt_template, messages, tool_types, call_kwargs = setup_call_openai(
-        model=model,  # pyright: ignore [reportCallIssue]
-        client=client,  # pyright: ignore [reportArgumentType]
-        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,
-    )
-    return create, prompt_template, messages, tool_types, call_kwargs

mirascope/core/xai/call_params.py

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

mirascope/core/xai/call_response.py

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

mirascope/core/xai/call_response_chunk.py

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

mirascope/core/xai/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
-
-AsyncXAIDynamicConfig: TypeAlias = AsyncOpenAIDynamicConfig
-XAIDynamicConfig: TypeAlias = OpenAIDynamicConfig

mirascope/core/xai/stream.py

@@ -1,57 +0,0 @@
-"""The `XAIStream` class for convenience around streaming xAI LLM calls.
-
-usage docs: learn/streams.md
-"""
-
-from collections.abc import AsyncGenerator, Generator
-
-from ..openai import OpenAIStream
-from .call_response import XAICallResponse
-from .call_response_chunk import XAICallResponseChunk
-from .tool import XAITool
-
-
-class XAIStream(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 xAI's cost
-    calculation method. This ensures cost calculation works for non-OpenAI models.
-    """
-
-    _provider = "xai"
-
-    def __iter__(
-        self,
-    ) -> Generator[tuple[XAICallResponseChunk, XAITool | None], None, None]:
-        yield from super().__iter__()  # pyright: ignore [reportReturnType]
-
-    def __aiter__(
-        self,
-    ) -> AsyncGenerator[tuple[XAICallResponseChunk, XAITool | None], None]:
-        return super().__aiter__()  # pyright: ignore [reportReturnType] # pragma: no cover
-
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        response = self.construct_call_response()
-        return response.cost
-
-    def construct_call_response(self) -> XAICallResponse:
-        openai_call_response = super().construct_call_response()
-        response = XAICallResponse(
-            metadata=openai_call_response.metadata,
-            response=openai_call_response.response,
-            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/xai/tool.py

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

mirascope/experimental/graphs/__init__.py

@@ -1,5 +0,0 @@
-"""The Experimental Mirascope Graphs Module."""
-
-from .finite_state_machine import FiniteStateMachine, RunContext
-
-__all__ = ["FiniteStateMachine", "RunContext"]

mirascope/integrations/__init__.py

@@ -1,16 +0,0 @@
-"""Integrations with third party libraries."""
-
-from contextlib import suppress
-
-from ._middleware_factory import middleware_factory
-
-with suppress(ImportError):
-    from . import logfire as logfire
-
-with suppress(ImportError):
-    from . import langfuse as langfuse
-
-with suppress(ImportError):
-    from . import otel as otel
-
-__all__ = ["langfuse", "logfire", "middleware_factory", "otel"]