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

mirascope/integrations/_middleware_factory.py

@@ -1,277 +0,0 @@
-"""The `middleware_factory` method for handling the call response."""
-
-import inspect
-from collections.abc import AsyncGenerator, Awaitable, Callable, Generator
-from contextlib import AbstractContextManager, contextmanager
-from functools import wraps
-from typing import (
-    Any,
-    ParamSpec,
-    TypeVar,
-    cast,
-    overload,
-)
-
-from pydantic import BaseModel
-
-from mirascope.core.base._utils._base_type import BaseType
-
-from ..core.base.call_response import BaseCallResponse
-from ..core.base.stream import BaseStream
-from ..core.base.structured_stream import BaseStructuredStream
-
-_BaseCallResponseT = TypeVar("_BaseCallResponseT", bound=BaseCallResponse)
-_BaseStructuredStreamT = TypeVar("_BaseStructuredStreamT", bound=BaseStructuredStream)
-_BaseStreamT = TypeVar("_BaseStreamT", bound=BaseStream)
-_ResponseModelT = TypeVar("_ResponseModelT", bound=BaseModel | BaseType)
-ResponseModel = BaseModel | BaseType
-_P = ParamSpec("_P")
-SyncFunc = Callable[
-    _P, _BaseCallResponseT | _BaseStreamT | _ResponseModelT | _BaseStructuredStreamT
-]
-AsyncFunc = Callable[
-    _P,
-    Awaitable[
-        _BaseCallResponseT | _BaseStreamT | _ResponseModelT | _BaseStructuredStreamT
-    ],
-]
-_T = TypeVar("_T")
-_R = TypeVar("_R")
-
-
-@contextmanager
-def default_context_manager(
-    fn: SyncFunc | AsyncFunc,
-) -> Generator[None, None, None]:
-    yield None
-
-
-def middleware_factory(
-    custom_context_manager: Callable[
-        [SyncFunc | AsyncFunc], AbstractContextManager[_T]
-    ] = default_context_manager,
-    custom_decorator: Callable | None = None,
-    handle_call_response: Callable[
-        [BaseCallResponse, SyncFunc | AsyncFunc, _T | None], None
-    ]
-    | None = None,
-    handle_call_response_async: Callable[
-        [BaseCallResponse, SyncFunc | AsyncFunc, _T | None], Awaitable[None]
-    ]
-    | None = None,
-    handle_stream: Callable[[BaseStream, SyncFunc | AsyncFunc, _T | None], None]
-    | None = None,
-    handle_stream_async: Callable[
-        [BaseStream, SyncFunc | AsyncFunc, _T | None], Awaitable[None]
-    ]
-    | None = None,
-    handle_response_model: Callable[
-        [ResponseModel, SyncFunc | AsyncFunc, _T | None], None
-    ]
-    | None = None,
-    handle_response_model_async: Callable[
-        [ResponseModel, SyncFunc | AsyncFunc, _T | None], Awaitable[None]
-    ]
-    | None = None,
-    handle_structured_stream: Callable[
-        [BaseStructuredStream, SyncFunc | AsyncFunc, _T | None], None
-    ]
-    | None = None,
-    handle_structured_stream_async: Callable[
-        [BaseStructuredStream, SyncFunc | AsyncFunc, _T | None], Awaitable[None]
-    ]
-    | None = None,
-) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]:
-    '''A factory method for creating middleware decorators.
-
-    Example:
-
-    ```python
-    from mirascope.core import openai, prompt_template
-    from mirascope.integrations import middleware_factory
-
-    def with_saving():
-        """Saves some data after a Mirascope call."""
-
-        return middleware_factory(
-            custom_context_manager=custom_context_manager,
-            custom_decorator=custom_decorator,
-            handle_call_response=handle_call_response,
-            handle_call_response_async=handle_call_response_async,
-            handle_stream=handle_stream,
-            handle_stream_async=handle_stream_async,
-            handle_response_model=handle_response_model,
-            handle_response_model_async=handle_response_model_async,
-            handle_structured_stream=handle_structured_stream,
-            handle_structured_stream_async=handle_structured_stream_async,
-        )
-
-
-    @with_saving()
-    @openai.call("gpt-4o-mini")
-    @prompt_template("Recommend a {genre} book")
-    def recommend_book(genre: str):
-        ...
-
-
-    response = recommend_book("fantasy")  # `with_saving` automatically run
-    print(response.content)
-    ```
-    '''
-
-    @overload
-    def decorator(fn: Callable[_P, _R]) -> Callable[_P, _R]: ...
-
-    @overload
-    def decorator(fn: Callable[_P, Awaitable[_R]]) -> Callable[_P, Awaitable[_R]]: ...
-
-    def decorator(
-        fn: Callable[_P, _R | Awaitable[_R]],
-    ) -> Callable[_P, _R | Awaitable[_R]]:
-        if inspect.iscoroutinefunction(fn):
-
-            @wraps(fn)
-            async def wrapper_async(*args: _P.args, **kwargs: _P.kwargs) -> _R:
-                result = await fn(*args, **kwargs)
-                if (
-                    isinstance(result, BaseCallResponse)
-                    and handle_call_response_async is not None
-                ):
-                    with custom_context_manager(fn) as context:
-                        await handle_call_response_async(result, fn, context)
-                elif isinstance(result, BaseStream):
-                    original_class = type(result)
-                    original_aiter = result.__aiter__
-
-                    def new_stream_aiter(
-                        self: Any,  # noqa: ANN401
-                    ) -> AsyncGenerator[tuple[Any, Any | None], Any]:  # noqa: ANN401
-                        async def generator() -> (
-                            AsyncGenerator[tuple[Any, Any | None], Any]
-                        ):
-                            with custom_context_manager(fn) as context:
-                                async for chunk, tool in original_aiter():
-                                    yield chunk, tool
-                                if handle_stream_async is not None:
-                                    await handle_stream_async(result, fn, context)
-
-                        return generator()
-
-                    class MiddlewareAsyncStream(original_class):
-                        __aiter__ = (
-                            custom_decorator(fn)(new_stream_aiter)
-                            if custom_decorator
-                            else new_stream_aiter
-                        )
-
-                    result.__class__ = MiddlewareAsyncStream
-                elif (
-                    isinstance(result, ResponseModel)
-                    and handle_response_model_async is not None
-                ):
-                    with custom_context_manager(fn) as context:
-                        await handle_response_model_async(result, fn, context)
-                elif isinstance(result, BaseStructuredStream):
-                    original_class = type(result)
-                    original_aiter = result.__aiter__
-
-                    def new_aiter(
-                        self: Any,  # noqa: ANN401
-                    ) -> AsyncGenerator[tuple[Any, Any | None], Any]:  # noqa: ANN401
-                        async def generator() -> (
-                            AsyncGenerator[tuple[Any, Any | None], Any]
-                        ):
-                            with custom_context_manager(fn) as context:
-                                async for chunk in original_aiter():
-                                    yield chunk
-                                if handle_structured_stream_async is not None:
-                                    await handle_structured_stream_async(
-                                        result, fn, context
-                                    )
-
-                        return generator()
-
-                    class MiddlewareAsyncStructuredStream(original_class):
-                        __aiter__ = (
-                            custom_decorator(fn)(new_aiter)
-                            if custom_decorator
-                            else new_aiter
-                        )
-
-                    result.__class__ = MiddlewareAsyncStructuredStream
-                return cast(_R, result)
-
-            return (
-                custom_decorator(fn)(wrapper_async)
-                if custom_decorator
-                else wrapper_async
-            )
-        else:
-
-            @wraps(fn)
-            def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R:
-                result = fn(*args, **kwargs)
-                if (
-                    isinstance(result, BaseCallResponse)
-                    and handle_call_response is not None
-                ):
-                    with custom_context_manager(fn) as context:
-                        handle_call_response(result, fn, context)
-                elif isinstance(result, BaseStream):
-                    original_class = type(result)
-                    original_iter = result.__iter__
-
-                    def new_stream_iter(
-                        self: Any,  # noqa: ANN401
-                    ) -> Generator[tuple[Any, Any | None], None, None]:  # noqa: ANN401
-                        # Create the context manager when user iterates over the stream
-                        with custom_context_manager(fn) as context:
-                            yield from original_iter()
-                            if handle_stream is not None:
-                                handle_stream(result, fn, context)
-
-                    class MiddlewareStream(original_class):
-                        __iter__ = (
-                            custom_decorator(fn)(new_stream_iter)
-                            if custom_decorator
-                            else new_stream_iter
-                        )
-
-                    result.__class__ = MiddlewareStream
-                elif (
-                    isinstance(result, ResponseModel)
-                    and handle_response_model is not None
-                ):
-                    with custom_context_manager(fn) as context:
-                        handle_response_model(result, fn, context)
-                elif isinstance(result, BaseStructuredStream):
-                    original_class = type(result)
-                    original_iter = result.__iter__
-
-                    def new_iter(
-                        self: Any,  # noqa: ANN401
-                    ) -> Generator[
-                        Generator[tuple[Any, Any | None], None, None]
-                        | Generator[Any, None, None],
-                        Any,
-                        None,
-                    ]:  # noqa: ANN401
-                        # Create the context manager when user iterates over the stream
-                        with custom_context_manager(fn) as context:
-                            yield from original_iter()
-                            if handle_structured_stream is not None:
-                                handle_structured_stream(result, fn, context)
-
-                    class MiddlewareStructuredStream(original_class):
-                        __iter__ = (
-                            custom_decorator(fn)(new_iter)
-                            if custom_decorator
-                            else new_iter
-                        )
-
-                    result.__class__ = MiddlewareStructuredStream
-                return cast(_R, result)
-
-            return custom_decorator(fn)(wrapper) if custom_decorator else wrapper
-
-    return decorator

mirascope/integrations/langfuse/__init__.py

@@ -1,3 +0,0 @@
-from ._with_langfuse import with_langfuse
-
-__all__ = ["with_langfuse"]

mirascope/integrations/langfuse/_utils.py

@@ -1,114 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-
-from langfuse.decorators import langfuse_context
-from pydantic import BaseModel
-
-from mirascope.core.base._utils._base_type import BaseType
-
-from ...core.base import BaseCallResponse
-from ...core.base._utils import get_metadata
-from ...core.base.stream import BaseStream
-from ...core.base.structured_stream import BaseStructuredStream
-
-
-class ModelUsage(BaseModel):
-    input: int | float | None
-    output: int | float | None
-    unit: str
-
-
-def get_call_response_observation(
-    result: BaseCallResponse, fn: Callable
-) -> dict[str, Any]:
-    metadata = get_metadata(fn, {})
-    tags = metadata.get("tags", [])
-    return {
-        "name": f"{fn.__name__} with {result.model}",
-        "input": result.prompt_template,
-        "metadata": result.response,
-        "tags": tags,
-        "model": result.model,
-        "output": result.message_param.get("content", None),
-    }
-
-
-def handle_call_response(result: BaseCallResponse, fn: Callable, context: None) -> None:
-    langfuse_context.update_current_observation(
-        **get_call_response_observation(result, fn),
-        usage=ModelUsage(
-            input=result.input_tokens, output=result.output_tokens, unit="TOKENS"
-        ),
-    )
-
-
-def handle_stream(stream: BaseStream, fn: Callable, context: None) -> None:
-    usage = ModelUsage(
-        input=stream.input_tokens,
-        output=stream.output_tokens,
-        unit="TOKENS",
-    )
-    langfuse_context.update_current_observation(
-        **get_call_response_observation(stream.construct_call_response(), fn),
-        usage=usage,
-    )
-
-
-def handle_response_model(
-    result: BaseModel | BaseType, fn: Callable, context: None
-) -> None:
-    if isinstance(result, BaseModel):
-        response: BaseCallResponse = result._response  # type: ignore
-        call_response_observation = get_call_response_observation(response, fn)
-        call_response_observation.pop("output")
-        langfuse_context.update_current_observation(
-            **call_response_observation,
-            usage=ModelUsage(
-                input=response.input_tokens,
-                output=response.output_tokens,
-                unit="TOKENS",
-            ),
-            output=result,
-        )
-    else:
-        langfuse_context.update_current_observation(
-            output=result,
-        )
-
-
-def handle_structured_stream(
-    result: BaseStructuredStream, fn: Callable, context: None
-) -> None:
-    stream: BaseStream = result.stream
-    usage = ModelUsage(
-        input=stream.input_tokens,
-        output=stream.output_tokens,
-        unit="TOKENS",
-    )
-    langfuse_context.update_current_observation(
-        **get_call_response_observation(stream.construct_call_response(), fn),
-        usage=usage,
-        output=result.constructed_response_model,
-    )
-
-
-async def handle_call_response_async(
-    result: BaseCallResponse, fn: Callable, context: None
-) -> None:
-    handle_call_response(result, fn, None)
-
-
-async def handle_stream_async(stream: BaseStream, fn: Callable, context: None) -> None:
-    handle_stream(stream, fn, None)
-
-
-async def handle_response_model_async(
-    result: BaseModel | BaseType, fn: Callable, context: None
-) -> None:
-    handle_response_model(result, fn, None)
-
-
-async def handle_structured_stream_async(
-    result: BaseStructuredStream, fn: Callable, context: None
-) -> None:
-    handle_structured_stream(result, fn, None)

mirascope/integrations/langfuse/_with_langfuse.py

@@ -1,71 +0,0 @@
-"""Mirascope x Langfuse Integration."""
-
-from collections.abc import Callable
-from typing import Any, ParamSpec, TypeVar
-
-from langfuse.decorators import observe
-
-from .._middleware_factory import middleware_factory
-from ._utils import (
-    handle_call_response,
-    handle_call_response_async,
-    handle_response_model,
-    handle_response_model_async,
-    handle_stream,
-    handle_stream_async,
-    handle_structured_stream,
-    handle_structured_stream_async,
-)
-
-F = TypeVar("F", bound=Callable[..., Any])
-
-
-def custom_decorator(fn: Callable) -> Callable[[F], F]:
-    return observe(
-        name=fn.__name__,
-        as_type="generation",
-        capture_input=False,
-        capture_output=False,
-    )
-
-
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
-
-
-def with_langfuse() -> Callable[[Callable[_P, _R]], Callable[_P, _R]]:
-    """Wraps a Mirascope function with Langfuse.
-
-    Example:
-
-    ```python
-    from mirascope.core import anthropic, prompt_template
-    from mirascope.integrations.langfuse import with_langfuse
-
-
-    def format_book(title: str, author: str):
-        return f"{title} by {author}"
-
-
-    @with_langfuse()
-    @anthropic.call(model="claude-3-5-sonnet-20240620", tools=[format_book])
-    @prompt_template("Recommend a {genre} book.")
-    def recommend_book(genre: str):
-        ...
-
-
-    print(recommend_book("fantasy"))
-    ```
-    """
-
-    return middleware_factory(
-        custom_decorator=custom_decorator,
-        handle_call_response=handle_call_response,
-        handle_call_response_async=handle_call_response_async,
-        handle_stream=handle_stream,
-        handle_stream_async=handle_stream_async,
-        handle_response_model=handle_response_model,
-        handle_response_model_async=handle_response_model_async,
-        handle_structured_stream=handle_structured_stream,
-        handle_structured_stream_async=handle_structured_stream_async,
-    )

mirascope/integrations/logfire/__init__.py

@@ -1,3 +0,0 @@
-from ._with_logfire import with_logfire
-
-__all__ = ["with_logfire"]

mirascope/integrations/logfire/_utils.py

@@ -1,188 +0,0 @@
-"""Mirascope x Logfire Integration utils"""
-
-from collections.abc import Callable, Generator
-from contextlib import contextmanager
-from typing import (
-    Any,
-)
-
-import logfire
-from pydantic import BaseModel
-
-from mirascope.core.base._utils._base_type import BaseType
-
-from ...core.base import BaseCallResponse, _utils
-from ...core.base.metadata import Metadata
-from ...core.base.stream import BaseStream
-from ...core.base.structured_stream import BaseStructuredStream
-
-
-@contextmanager
-def custom_context_manager(
-    fn: Callable,
-) -> Generator[logfire.LogfireSpan, Any, None]:
-    metadata: Metadata = _utils.get_metadata(fn, None)
-    tags = metadata.get("tags", [])
-    with logfire.with_settings(custom_scope_suffix="mirascope", tags=list(tags)).span(
-        fn.__name__
-    ) as logfire_span:
-        yield logfire_span
-
-
-def get_call_response_span_data(result: BaseCallResponse) -> dict:
-    output: dict[str, Any] = {}
-    if cost := result.cost:
-        output["cost"] = cost
-    if input_tokens := result.input_tokens:
-        output["input_tokens"] = input_tokens
-    if output_tokens := result.output_tokens:
-        output["output_tokens"] = output_tokens
-    if content := result.content:
-        output["content"] = content
-    return {
-        "async": False,
-        "call_params": result.call_params,
-        "call_kwargs": result.call_kwargs,
-        "model": result.model,
-        "provider": result._provider,
-        "prompt_template": result.prompt_template,
-        "template_variables": result.fn_args,
-        "messages": result.messages,
-        "response_data": result.response,
-        "output": output,
-    }
-
-
-def get_tool_calls(result: BaseCallResponse) -> list[dict] | None:
-    if tools := result.tools:
-        tool_calls = [
-            {
-                "function": {
-                    "arguments": tool.args,
-                    "name": tool._name(),
-                }
-            }
-            for tool in tools
-        ]
-        return tool_calls
-    return None
-
-
-def handle_call_response(
-    result: BaseCallResponse, fn: Callable, logfire_span: logfire.LogfireSpan | None
-) -> None:
-    if logfire_span is None:
-        return
-    span_data = get_call_response_span_data(result)
-    span_data["async"] = False
-    tool_calls = get_tool_calls(result)
-    if tool_calls:
-        span_data["output"]["tool_calls"] = tool_calls
-    logfire_span.set_attributes(span_data)
-
-
-def handle_stream(
-    stream: BaseStream,
-    fn: Callable,
-    logfire_span: logfire.LogfireSpan | None,
-) -> None:
-    handle_call_response(stream.construct_call_response(), fn, logfire_span)
-
-
-def set_response_model_output(
-    result: BaseModel | BaseType, output: dict[str, Any]
-) -> None:
-    if isinstance(result, BaseModel):
-        output["response_model"] = {
-            "name": result.__class__.__name__,
-            "arguments": result.model_dump(),
-        }
-    else:
-        output["content"] = result
-
-
-def handle_response_model(
-    result: BaseModel | BaseType, fn: Callable, logfire_span: logfire.LogfireSpan | None
-) -> None:
-    if logfire_span is None:
-        return
-    span_data: dict[str, Any] = {"output": {}, "async": False}
-    if isinstance(result, BaseModel):  # type: ignore
-        response: BaseCallResponse = result._response  # type: ignore
-        span_data |= get_call_response_span_data(response)
-    set_response_model_output(result, span_data["output"])
-    logfire_span.set_attributes(span_data)
-
-
-def get_structured_stream_span_data(result: BaseStructuredStream) -> dict:
-    span_data = get_call_response_span_data(result.stream.construct_call_response())
-    output = span_data.get("output", {})
-    response_model = result.constructed_response_model
-    if isinstance(response_model, BaseModel):
-        output["response_model"] = {
-            "name": response_model.__class__.__name__,
-            "arguments": response_model.model_dump(),
-        }
-    else:
-        output["content"] = response_model
-    span_data["output"] = output
-
-    return span_data
-
-
-def handle_structured_stream(
-    result: BaseStructuredStream, fn: Callable, logfire_span: logfire.LogfireSpan | None
-) -> None:
-    if logfire_span is None:
-        return
-    span_data = get_structured_stream_span_data(result)
-    span_data["async"] = False
-    logfire_span.set_attributes(span_data)
-
-
-async def handle_call_response_async(
-    result: BaseCallResponse, fn: Callable, logfire_span: logfire.LogfireSpan | None
-) -> None:
-    if logfire_span is None:
-        return
-    span_data = get_call_response_span_data(result)
-    span_data["async"] = True
-    tool_calls = get_tool_calls(result)
-    if tool_calls:
-        span_data["output"]["tool_calls"] = tool_calls
-    logfire_span.set_attributes(span_data)
-
-
-async def handle_stream_async(
-    stream: BaseStream,
-    fn: Callable,
-    logfire_span: logfire.LogfireSpan | None,
-) -> None:
-    await handle_call_response_async(stream.construct_call_response(), fn, logfire_span)
-
-
-async def handle_response_model_async(
-    result: BaseModel | BaseType,
-    fn: Callable,
-    logfire_span: logfire.LogfireSpan | None,
-) -> None:
-    if logfire_span is None:
-        return
-    span_data: dict[str, Any] = {"output": {}, "async": True}
-    if isinstance(result, BaseModel):  # type: ignore
-        response: BaseCallResponse = result._response  # type: ignore
-        span_data |= get_call_response_span_data(response)
-    set_response_model_output(result, span_data["output"])
-    logfire_span.set_attributes(span_data)
-
-
-async def handle_structured_stream_async(
-    result: BaseStructuredStream,
-    fn: Callable,
-    logfire_span: logfire.LogfireSpan | None,
-) -> None:
-    if logfire_span is None:
-        return
-    span_data = get_structured_stream_span_data(result)
-    span_data["async"] = True
-    logfire_span.set_attributes(span_data)