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

mirascope/integrations/logfire/_utils.py

@@ -1,225 +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(  # pyright: ignore[reportGeneralTypeIssues]
-        fn.__name__
-    ) as logfire_span:
-        yield logfire_span
-
-
-def _get_call_response_span_data(result: BaseCallResponse) -> dict[str, Any]:
-    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 or "",
-        "template_variables": result.fn_args,
-        "messages": result.messages,
-        "response_data": result.response,
-        "output": output,
-    }
-
-
-def _get_tool_calls(result: BaseCallResponse) -> list[dict[str, Any]] | 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):
-        response: BaseCallResponse = result._response  # pyright: ignore [reportAttributeAccessIssue]
-        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[str, Any]:
-    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)
-
-
-def _get_error_span_data(e: Exception, fn: Callable) -> dict[str, Any]:
-    span_data: dict[str, Any] = {}
-    if hasattr(e, "_response"):
-        response: BaseCallResponse = e._response  # pyright: ignore [reportAttributeAccessIssue]
-        span_data = _get_call_response_span_data(response)
-        tool_calls = _get_tool_calls(response)
-        if tool_calls:
-            span_data["output"]["tool_calls"] = tool_calls
-    span_data["error"] = type(e).__name__
-    span_data["error_message"] = str(e)
-    return span_data
-
-
-def handle_error(
-    e: Exception, fn: Callable, logfire_span: logfire.LogfireSpan | None
-) -> None:
-    if logfire_span is None:
-        return
-    span_data = _get_error_span_data(e, fn)
-    span_data["async"] = False
-    logfire_span.set_attributes(span_data)
-    # propagate error
-    raise e
-
-
-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):
-        response: BaseCallResponse = result._response  # pyright: ignore [reportAttributeAccessIssue]
-        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)
-
-
-async def handle_error_async(
-    e: Exception, fn: Callable, logfire_span: logfire.LogfireSpan | None
-) -> None:
-    if logfire_span is None:
-        return
-    span_data = _get_error_span_data(e, fn)
-    span_data["async"] = True
-    logfire_span.set_attributes(span_data)
-    # propagate error
-    raise e

mirascope/integrations/logfire/_with_logfire.py

@@ -1,63 +0,0 @@
-"""Mirascope x Logfire Integration."""
-
-from collections.abc import Callable
-from typing import ParamSpec, TypeVar
-
-from .._middleware_factory import middleware_factory
-from ._utils import (
-    custom_context_manager,
-    handle_call_response,
-    handle_call_response_async,
-    handle_error,
-    handle_error_async,
-    handle_response_model,
-    handle_response_model_async,
-    handle_stream,
-    handle_stream_async,
-    handle_structured_stream,
-    handle_structured_stream_async,
-)
-
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
-
-
-def with_logfire() -> Callable[[Callable[_P, _R]], Callable[_P, _R]]:
-    """Wraps a Mirascope function with Logfire tracing.
-
-    Example:
-
-    ```python
-    import logfire
-    from mirascope.core import anthropic, prompt_template
-    from mirascope.integrations.logfire import with_logfire
-
-    logfire.configure()
-
-
-    def format_book(title: str, author: str):
-        return f"{title} by {author}"
-
-
-    @with_logfire()
-    @anthropic.call(model="claude-3-5-sonnet-20240620", tools=[format_book])
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    print(recommend_book("fantasy"))
-    ```
-    """
-    return middleware_factory(
-        custom_context_manager=custom_context_manager,
-        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,
-        handle_error=handle_error,
-        handle_error_async=handle_error_async,
-    )

mirascope/integrations/otel/__init__.py

@@ -1,10 +0,0 @@
-from contextlib import suppress
-
-from ._utils import configure
-
-with suppress(ImportError):
-    from ._with_hyperdx import with_hyperdx
-
-from ._with_otel import with_otel
-
-__all__ = ["configure", "with_hyperdx", "with_otel"]

mirascope/integrations/otel/_utils.py

@@ -1,270 +0,0 @@
-"""Mirascope x OpenTelemetry Integration utils"""
-
-import json
-from collections.abc import Callable, Generator, Sequence
-from contextlib import contextmanager
-from typing import Any
-
-from opentelemetry.sdk.trace import SpanProcessor, TracerProvider
-from opentelemetry.sdk.trace.export import (
-    ConsoleSpanExporter,
-    SimpleSpanProcessor,
-)
-from opentelemetry.trace import (
-    Tracer,
-    get_tracer,
-    set_tracer_provider,
-)
-from opentelemetry.trace.span import Span
-from opentelemetry.util.types import Attributes, AttributeValue
-from pydantic import BaseModel
-
-from mirascope.core.base._utils._base_type import BaseType
-
-from ...core.base import BaseCallResponse
-from ...core.base.stream import BaseStream
-from ...core.base.structured_stream import BaseStructuredStream
-
-
-def configure(
-    processors: Sequence[SpanProcessor] | None = None,
-) -> Tracer:
-    """Configures the OpenTelemetry tracer, this function should only be called once.
-
-    Args:
-        processors: Optional[Sequence[SpanProcessor]]
-            The span processors to use, if None, a console exporter will be used.
-
-    Returns:
-        The configured tracer.
-    """
-    provider = TracerProvider()
-    if processors is None:
-        provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
-    else:
-        for processor in processors:
-            provider.add_span_processor(processor)
-    # NOTE: Sets the global trace provider, should only be called once
-    set_tracer_provider(provider)
-    return get_tracer("otel")
-
-
-@contextmanager
-def custom_context_manager(
-    fn: Callable,
-) -> Generator[Span, Any, None]:
-    tracer = get_tracer("otel")
-    with tracer.start_as_current_span(f"{fn.__name__}") as span:
-        yield span
-
-
-def _get_call_response_attributes(
-    result: BaseCallResponse,
-) -> dict[str, AttributeValue]:
-    max_tokens = getattr(result.call_params, "max_tokens", 0)
-    temperature = getattr(result.call_params, "temperature", 0)
-    top_p = getattr(result.call_params, "top_p", 0)
-
-    return {
-        "gen_ai.system": result.prompt_template if result.prompt_template else "",
-        "gen_ai.request.model": result.call_kwargs.get("model", ""),
-        "gen_ai.request.max_tokens": max_tokens,
-        "gen_ai.request.temperature": temperature,
-        "gen_ai.request.top_p": top_p,
-        "gen_ai.response.model": result.model if result.model else "",
-        "gen_ai.response.id": result.id if result.id else "",
-        "gen_ai.response.finish_reasons": result.finish_reasons
-        if result.finish_reasons
-        else "",
-        "gen_ai.usage.completion_tokens": result.output_tokens
-        if result.output_tokens
-        else "",
-        "gen_ai.usage.prompt_tokens": result.input_tokens
-        if result.input_tokens
-        else "",
-    }
-
-
-def _set_call_response_event_attributes(result: BaseCallResponse, span: Span) -> None:
-    prompt_attributes = {
-        "gen_ai.prompt": json.dumps(result.user_message_param),
-    }
-    completion_attributes: Attributes = {
-        "gen_ai.completion": json.dumps(result.message_param),
-    }
-    span.add_event(
-        "gen_ai.content.prompt",
-        attributes=prompt_attributes,
-    )
-    span.add_event(
-        "gen_ai.content.completion",
-        attributes=completion_attributes,
-    )
-
-
-def handle_call_response(
-    result: BaseCallResponse, fn: Callable, span: Span | None
-) -> None:
-    if span is None:
-        return
-
-    attributes = _get_call_response_attributes(result)
-    attributes["async"] = False
-    span.set_attributes(attributes)
-    _set_call_response_event_attributes(result, span)
-
-
-def handle_stream(stream: BaseStream, fn: Callable, span: Span | None) -> None:
-    if span is None:
-        return
-    constructed_call_response = stream.construct_call_response()
-    attributes = _get_call_response_attributes(constructed_call_response)
-    attributes["async"] = False
-    span.set_attributes(attributes)
-    _set_call_response_event_attributes(constructed_call_response, span)
-
-
-def handle_response_model(
-    result: BaseModel | BaseType, fn: Callable, span: Span | None
-) -> None:
-    if span is None:
-        return
-    if isinstance(result, BaseModel):
-        response: BaseCallResponse = result._response  # pyright: ignore [reportAttributeAccessIssue]
-        attributes = _get_call_response_attributes(response)
-        attributes["async"] = False
-        span.set_attributes(attributes)
-        prompt_attributes = {
-            "gen_ai.prompt": json.dumps(response.user_message_param),
-        }
-        completion_attributes: Attributes = {
-            "gen_ai.completion": result.model_dump_json(),
-        }
-        span.add_event(
-            "gen_ai.content.prompt",
-            attributes=prompt_attributes,
-        )
-    else:
-        span.set_attributes({"async": False})
-        if not isinstance(result, str | int | float | bool):
-            result = str(result)
-        completion_attributes: Attributes = {
-            "gen_ai.completion": result,
-        }
-    span.add_event(
-        "gen_ai.content.completion",
-        attributes=completion_attributes,
-    )
-
-
-def handle_structured_stream(
-    result: BaseStructuredStream, fn: Callable, span: Span | None
-) -> None:
-    if span is None:
-        return
-    attributes = _get_call_response_attributes(result.stream.construct_call_response())
-    attributes["async"] = False
-    span.set_attributes(attributes)
-    prompt_attributes = {
-        "gen_ai.prompt": json.dumps(result.stream.user_message_param),
-    }
-    if isinstance(result.constructed_response_model, BaseModel):
-        completion = result.constructed_response_model.model_dump_json()
-    else:
-        completion = result.constructed_response_model
-    completion_attributes: Attributes = {
-        "gen_ai.completion": completion,
-    }
-    span.add_event(
-        "gen_ai.content.prompt",
-        attributes=prompt_attributes,
-    )
-    span.add_event(
-        "gen_ai.content.completion",
-        attributes=completion_attributes,
-    )
-
-
-async def handle_call_response_async(
-    result: BaseCallResponse, fn: Callable, span: Span | None
-) -> None:
-    if span is None:
-        return
-
-    attributes = _get_call_response_attributes(result)
-    attributes["async"] = True
-    span.set_attributes(attributes)
-    _set_call_response_event_attributes(result, span)
-
-
-async def handle_stream_async(
-    stream: BaseStream, fn: Callable, span: Span | None
-) -> None:
-    if span is None:
-        return
-    constructed_call_response = stream.construct_call_response()
-    attributes = _get_call_response_attributes(constructed_call_response)
-    attributes["async"] = True
-    span.set_attributes(attributes)
-    _set_call_response_event_attributes(constructed_call_response, span)
-
-
-async def handle_response_model_async(
-    result: BaseModel | BaseType, fn: Callable, span: Span | None
-) -> None:
-    if span is None:
-        return
-    if isinstance(result, BaseModel):
-        response: BaseCallResponse = result._response  # pyright: ignore [reportAttributeAccessIssue]
-        attributes = _get_call_response_attributes(response)
-        attributes["async"] = True
-        span.set_attributes(attributes)
-        prompt_attributes = {
-            "gen_ai.prompt": json.dumps(response.user_message_param),
-        }
-        completion_attributes: Attributes = {
-            "gen_ai.completion": result.model_dump_json(),
-        }
-        span.add_event(
-            "gen_ai.content.prompt",
-            attributes=prompt_attributes,
-        )
-    else:
-        span.set_attributes({"async": True})
-        if not isinstance(result, str | int | float | bool):
-            result = str(result)
-        completion_attributes: Attributes = {
-            "gen_ai.completion": result,
-        }
-    span.add_event(
-        "gen_ai.content.completion",
-        attributes=completion_attributes,
-    )
-
-
-async def handle_structured_stream_async(
-    result: BaseStructuredStream, fn: Callable, span: Span | None
-) -> None:
-    if span is None:
-        return
-    attributes = _get_call_response_attributes(result.stream.construct_call_response())
-    attributes["async"] = True
-    span.set_attributes(attributes)
-    prompt_attributes = {
-        "gen_ai.prompt": json.dumps(result.stream.user_message_param),
-    }
-    if isinstance(result.constructed_response_model, BaseModel):
-        completion = result.constructed_response_model.model_dump_json()
-    else:
-        completion = result.constructed_response_model
-    completion_attributes: Attributes = {
-        "gen_ai.completion": completion,
-    }
-    span.add_event(
-        "gen_ai.content.prompt",
-        attributes=prompt_attributes,
-    )
-    span.add_event(
-        "gen_ai.content.completion",
-        attributes=completion_attributes,
-    )

mirascope/integrations/otel/_with_hyperdx.py

@@ -1,60 +0,0 @@
-"""Mirascope x HyperDX Integration."""
-
-import os
-from collections.abc import Callable
-from typing import ParamSpec, TypeVar
-
-from opentelemetry import trace
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import (
-    BatchSpanProcessor,
-)
-
-from mirascope.integrations.otel._utils import configure
-from mirascope.integrations.otel._with_otel import with_otel
-
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
-
-
-def with_hyperdx() -> Callable[[Callable[_P, _R]], Callable[_P, _R]]:
-    """Decorator to wrap a function with hyperdx.
-
-    Example:
-
-    ```python
-    import os
-
-    from mirascope.core import anthropic, prompt_template
-    from mirascope.integrations.otel import with_hyperdx
-
-    os.environ["HYPERDX_API_KEY"] = "YOUR_API_KEY"
-
-
-    def format_book(title: str, author: str):
-        return f"{title} by {author}"
-
-
-    @with_hyperdx()
-    @anthropic.call(model="claude-3-5-sonnet-20240620", tools=[format_book])
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    print(recommend_book("fantasy"))
-    ```
-    """
-    provider = trace.get_tracer_provider()
-    if not isinstance(provider, TracerProvider):
-        configure(
-            processors=[
-                BatchSpanProcessor(
-                    OTLPSpanExporter(
-                        endpoint="https://in-otel.hyperdx.io/v1/traces",
-                        headers={"authorization": os.getenv("HYPERDX_API_KEY", "")},
-                    )
-                )
-            ]
-        )
-    return with_otel()

mirascope/integrations/otel/_with_otel.py

@@ -1,59 +0,0 @@
-"""Mirascope x OpenTelemetry Integration."""
-
-from collections.abc import Callable
-from typing import ParamSpec, TypeVar
-
-from .._middleware_factory import middleware_factory
-from ._utils import (
-    custom_context_manager,
-    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,
-)
-
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
-
-
-def with_otel() -> Callable[[Callable[_P, _R]], Callable[_P, _R]]:
-    """Wraps a Mirascope function with OpenTelemetry.
-
-    Example:
-
-    ```python
-    from mirascope.core import anthropic, prompt_template
-    from mirascope.integrations.otel import with_otel, configure
-
-    configure()
-
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-
-    @with_otel()
-    @anthropic.call(model="claude-3-5-sonnet-20240620", tools=[format_book])
-    def recommend_book(genre: str) -> str:
-        return f"Recommend a {genre} book"
-
-
-    print(recommend_book("fantasy"))
-    ```
-    """
-
-    return middleware_factory(
-        custom_context_manager=custom_context_manager,
-        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/tenacity.py

@@ -1,14 +0,0 @@
-"""DEPRECATED."""
-
-import inspect
-import warnings
-
-from ..retries.tenacity import collect_errors
-
-warnings.warn(
-    inspect.cleandoc("""
-    The import `mirascope.integrations.tenacity` is deprecated in versions `>=1.3`.
-    Please instead use the `mirascope.retries.tenacity` import.
-    """)
-)
-__all__ = ["collect_errors"]