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

mirascope/integrations/logfire/_with_logfire.py

@@ -1,60 +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_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])
-    @prompt_template("Recommend a {genre} book.")
-    def recommend_book(genre: str):
-        ...
-
-
-    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/otel/__init__.py

@@ -1,5 +0,0 @@
-from ._utils import configure
-from ._with_hyperdx import with_hyperdx
-from ._with_otel import with_otel
-
-__all__ = ["configure", "with_hyperdx", "with_otel"]

mirascope/integrations/otel/_utils.py

@@ -1,268 +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  # type: ignore
-        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  # type: ignore
-        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,61 +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])
-    @prompt_template("Recommend a {genre} book.")
-    def recommend_book(genre: str):
-        ...
-
-
-    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,60 +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])
-    @prompt_template("Recommend a {genre} book.")
-    def recommend_book(genre: str):
-        ...
-
-
-    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,50 +0,0 @@
-"""Mirascope x Tenacity Integration."""
-
-from collections.abc import Callable
-
-from tenacity import RetryCallState
-
-
-def collect_errors(
-    *args: type[Exception],
-) -> Callable[[RetryCallState], None]:
-    """Collects specified errors into an `errors` keyword argument.
-
-    Example:
-
-    ```python
-    from mirascope.integrations.tenacity import collect_errors
-    from tenacity import retry, stop_after_attempt
-
-    @retry(stop=stop_after_attempt(3), after=collect_errors(ValueError))
-    def throw_value_error(*, errors: list[ValueError] | None = None):
-        if errors:
-            print(errors[-1])
-        raise ValueError("Throwing Error")
-
-
-    try:
-        throw_value_error()
-        # > Throwing Error
-        # > Throwing Error
-    except RetryError:
-        ...
-    ```
-
-    Args:
-        *args: The `Exception` types to catch.
-    """
-
-    def inner(retry_state: RetryCallState) -> None:
-        """Collect errors into a `errors` kwarg of the wrapped function."""
-        if (
-            (outcome := retry_state.outcome)
-            and (exception := outcome.exception())
-            and type(exception) in args
-        ):
-            errors = retry_state.kwargs.pop("errors", [])
-            retry_state.kwargs["errors"] = (
-                errors + [exception] if errors else [exception]
-            )
-
-    return inner

mirascope/v0/__init__.py

@@ -1,43 +0,0 @@
-import warnings
-from contextlib import suppress
-
-from . import base
-
-with suppress(ImportError):
-    from . import anthropic
-
-with suppress(ImportError):
-    from . import openai
-
-
-warnings.warn("""MIRASCOPE LOOK-ALIKE V0 INTERFACE USAGE
-    You are using the `mirascope.v0` module, which implements look-alike interfaces.
-    It is extremely important to note the following about these interfaces:
-        - We provide no guarantee that we will support these interfaces. This includes any additional features or bugfixes.
-        - We reserve the right to remove these interfaces from the library entirely.
-        - These interfaces are an attempt at replicating the v0 interfaces, but they are built using v1 under the hood.
-        - This means that you can access certain v1 features through these interfaces (such as multimodal prompt templates).
-        - However, this also means that there are inevitable differences (e.g. `OpenAICallResponse` returned from `call` is the `v1` implementation).
-    
-    The goal of these interfaces is to make it possible to migrate from v0 to v1 without requiring a full migration.
-    HOWEVER, there are a few key differences to note:
-        - STREAMING:
-            - Was annoying to replicate, so we have instead opted to support streaming with the v1 return typing.
-            - The return type is a tuple[Chunk, Tool], so if you're not using tools, simply ignore the second item (e.g. `for chunk, _ in stream: ...`)
-            - If you're using tools, simply access tools as they are streamed through the second tuple item (i.e. no more `OpenAIToolStream`)
-        - BASE CONFIG:
-            - Was also annoying to replicate, so we've opted not to replicate this.
-            - To provide a custom client (e.g. `AzureOpenAI`), simply pass that client into your function (e.g. `book_recommender.call(client=AzureOpenAI(...))`) and we'll use it.
-            - This means there is no longer a `BaseConfig` object on anything.
-        - We currently only support the v0 look-alike interfaces for Anthropic and OpenAI.
-        - The import structure may differ slightly. In particular, there are no submodules for `anthropic` or `openai`, so you should be importing directly from those modules (e.g. `from mirascope.v0.openai import OpenAICall`)
-              
-    Next steps:
-        - We encourage you to try out the new v1 interface and mirgrate over. We think it's a big improvement, and we hope you will come to feel this way too.
-              - We've written a migration guide to help with this process: https://mirascope.io/docs/latest/MIGRATE
-        - We greatly appreciate any and all questions/comments/feedback, so if you have anything, send it our way!
-        - We understand that some people may prefer the class approach from v0 interface design. You can achieve a very similar interface using v1, see https://mirascope.io/docs/latest/MIGRATE/#baseprompt
-        - If there turns out to be sufficient desire for the class-based interfaces to be included in v1 as fully supported interfaces, we will potentially consider this.
-""")
-
-__all__ = ["anthropic", "base", "openai"]

mirascope/v0/anthropic.py

@@ -1,54 +0,0 @@
-"""OpenAI modules for the v0 look-alike implementation."""
-
-from typing import ClassVar, Generic, Literal, TypeVar
-
-from anthropic.types.completion_create_params import Metadata
-from pydantic import ConfigDict
-
-from ..core.anthropic import (
-    AnthropicCallResponse,
-    AnthropicCallResponseChunk,
-    AnthropicTool,
-    anthropic_call,
-)
-from .base import BaseCall, BaseCallParams, BaseExtractor, ExtractedType
-
-
-class AnthropicCallParams(BaseCallParams):
-    """The parameters to use when calling d Claud API with a prompt."""
-
-    max_tokens: int = 1000
-    model: str = "claude-3-haiku-20240307"
-    metadata: Metadata | None = None
-    stop_sequences: list[str] | None = None
-    system: str | None = None
-    temperature: float | None = None
-    top_k: int | None = None
-    top_p: float | None = None
-
-    response_format: Literal["json"] | None = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
-
-
-class AnthropicCall(
-    BaseCall[AnthropicCallResponse, AnthropicCallResponseChunk, AnthropicTool]
-):
-    call_params: ClassVar[BaseCallParams] = AnthropicCallParams(
-        model="claude-3-5-sonnet-20240620"
-    )
-
-    _decorator = anthropic_call
-    _provider = "anthropic"
-
-
-T = TypeVar("T", bound=ExtractedType)
-
-
-class AnthropicExtractor(BaseExtractor[T], Generic[T]):
-    call_params: ClassVar[BaseCallParams] = AnthropicCallParams(
-        model="claude-3-5-sonnet-20240620"
-    )
-
-    _decorator = anthropic_call
-    _provider = "anthropic"

mirascope/v0/base/__init__.py

@@ -1,12 +0,0 @@
-from .calls import BaseCall
-from .extractors import BaseExtractor, ExtractedType
-from .prompts import tags
-from .types import BaseCallParams
-
-__all__ = [
-    "BaseCall",
-    "BaseCallParams",
-    "BaseExtractor",
-    "ExtractedType",
-    "tags",
-]