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

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.com/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.com/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",
-]

mirascope/v0/base/calls.py

@@ -1,118 +0,0 @@
-from collections.abc import AsyncGenerator, Callable, Generator
-from typing import Any, ClassVar, Generic, TypeVar
-
-from pydantic import model_validator
-from tenacity import AsyncRetrying, Retrying
-from typing_extensions import Self
-
-from ...core.base import (
-    BaseCallResponse,
-    BaseCallResponseChunk,
-    BasePrompt,
-    BaseTool,
-    _utils,
-)
-from ...core.base.dynamic_config import DynamicConfigFull
-from .types import BaseCallParams
-from .utils import retry_decorator
-
-_BaseCallResponseT = TypeVar("_BaseCallResponseT", bound=BaseCallResponse)
-_BaseCallResponseChunkT = TypeVar(
-    "_BaseCallResponseChunkT", bound=BaseCallResponseChunk
-)
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-
-
-class BaseCall(
-    BasePrompt, Generic[_BaseCallResponseT, _BaseCallResponseChunkT, _BaseToolT]
-):
-    tags: ClassVar[list[str]] = []
-    prompt_template: ClassVar[str] = ""
-
-    call_params: ClassVar[BaseCallParams] = BaseCallParams(model="")
-
-    _decorator: ClassVar[Callable] = lambda self: None
-    _provider: ClassVar[str] = "NO PROVIDER"
-
-    @model_validator(mode="after")
-    def set_prompt_template(self) -> Self:
-        self._prompt_template = self.prompt_template
-        return self
-
-    def dynamic_config(self) -> DynamicConfigFull:
-        """Returns the dynamic configuration set from user provided information."""
-        config: DynamicConfigFull = {
-            "call_params": self.call_params.model_dump(exclude={"model", "tools"}),
-            "tools": [
-                tool
-                if isinstance(tool, type)
-                else _utils.convert_function_to_base_tool(tool, BaseTool)
-                for tool in self.call_params.tools or []
-            ],
-        }
-        if hasattr(self, "messages"):
-            config["messages"] = self.messages()  # pyright: ignore [reportAttributeAccessIssue]
-        return config
-
-    def dump(
-        self,
-    ) -> dict[str, Any]:
-        """Dumps the contents of the prompt into a dictionary."""
-        return {
-            "tags": self.tags,
-            "template": _utils.get_prompt_template(self),
-            "inputs": self.model_dump(),
-        }
-
-    def call(
-        self,
-        retries: int | Retrying = 0,
-        client: Any | None = None,  # noqa: ANN401
-        **kwargs: Any,  # noqa: ANN401
-    ) -> _BaseCallResponseT:
-        """A call to an LLM."""
-        return self.run(
-            self.__class__._decorator(self.call_params.model, client=client),
-            retry_decorator(retries),
-        )  # pyright: ignore [reportReturnType]
-
-    async def call_async(
-        self,
-        retries: int | AsyncRetrying = 0,
-        client: Any | None = None,  # noqa: ANN401
-        **kwargs: Any,  # noqa: ANN401
-    ) -> _BaseCallResponseT:
-        """An asynchronous call to an LLM."""
-        return await self.run_async(
-            self.__class__._decorator(self.call_params.model, client=client),
-            retry_decorator(retries),
-        )  # pyright: ignore [reportReturnType]
-
-    def stream(
-        self,
-        retries: int | Retrying = 0,
-        client: Any | None = None,  # noqa: ANN401
-        **kwargs: Any,  # noqa: ANN401
-    ) -> Generator[tuple[_BaseCallResponseChunkT, _BaseToolT], None, None]:
-        """A call to an LLM that streams the response in chunks."""
-        yield from self.run(
-            self.__class__._decorator(
-                self.call_params.model, stream=True, client=client
-            ),
-            retry_decorator(retries),
-        )  # pyright: ignore [reportReturnType]
-
-    async def stream_async(
-        self,
-        retries: int | AsyncRetrying = 0,
-        client: Any | None = None,  # noqa: ANN401
-        **kwargs: Any,  # noqa: ANN401
-    ) -> AsyncGenerator[tuple[_BaseCallResponseChunkT, _BaseToolT], None]:
-        """A asynchronous call to an LLM that streams the response in chunks."""
-        async for chunk, tool in self.run_async(  # pyright: ignore [reportGeneralTypeIssues]
-            self.__class__._decorator(
-                self.call_params.model, stream=True, client=client
-            ),
-            retry_decorator(retries),
-        ):
-            yield chunk, tool

mirascope/v0/base/extractors.py

@@ -1,122 +0,0 @@
-from collections.abc import AsyncGenerator, Callable, Generator
-from typing import Any, ClassVar, Generic, TypeVar
-
-from pydantic import BaseModel, model_validator
-from tenacity import AsyncRetrying, Retrying
-from typing_extensions import Self
-
-from ...core.base import BasePrompt, BaseTool, _utils
-from ...core.base.dynamic_config import DynamicConfigFull
-from .types import BaseCallParams
-from .utils import retry_decorator
-
-ExtractedType = _utils.BaseType | BaseModel
-_ExtractedTypeT = TypeVar("_ExtractedTypeT", bound=ExtractedType)
-
-
-class BaseExtractor(BasePrompt, Generic[_ExtractedTypeT]):
-    extract_schema: type[_utils.BaseType] | type[BaseModel] | Callable
-    tags: ClassVar[list[str]] = []
-    prompt_template: ClassVar[str] = ""
-
-    call_params: ClassVar[BaseCallParams] = BaseCallParams(model="")
-
-    _decorator: ClassVar[Callable] = lambda self: None
-    _provider: ClassVar[str] = "NO PROVIDER"
-
-    @model_validator(mode="after")
-    def set_prompt_template(self) -> Self:
-        self._prompt_template = self.prompt_template
-        return self
-
-    def dynamic_config(self) -> DynamicConfigFull:
-        """Returns the dynamic configuration set from user provided information."""
-        config: DynamicConfigFull = {
-            "call_params": self.call_params.model_dump(exclude={"model", "tools"}),
-            "tools": [
-                tool
-                if isinstance(tool, type)
-                else _utils.convert_function_to_base_tool(tool, BaseTool)
-                for tool in self.call_params.tools or []
-            ],
-        }
-        if hasattr(self, "messages"):
-            config["messages"] = self.messages()  # pyright: ignore [reportAttributeAccessIssue]
-        return config
-
-    def dump(
-        self,
-    ) -> dict[str, Any]:
-        """Dumps the contents of the prompt into a dictionary."""
-        return {
-            "tags": self.tags,
-            "template": _utils.get_prompt_template(self),
-            "inputs": self.model_dump(),
-        }
-
-    def extract(
-        self,
-        retries: int | Retrying = 0,
-        client: Any | None = None,  # noqa: ANN401
-        **kwargs: Any,  # noqa: ANN401
-    ) -> _ExtractedTypeT:
-        """Extracts the `extract_schema` format from the response."""
-        return self.run(
-            self.__class__._decorator(
-                self.call_params.model,
-                response_model=self.extract_schema,
-                client=client,
-            ),
-            retry_decorator(retries),
-        )
-
-    async def extract_async(
-        self,
-        retries: int | Retrying = 0,
-        client: Any | None = None,  # noqa: ANN401
-        **kwargs: Any,  # noqa: ANN401
-    ) -> _ExtractedTypeT:
-        """Asynchronously extracts the `extract_schema` format from the response."""
-        return await self.run_async(
-            self.__class__._decorator(
-                self.call_params.model,
-                response_model=self.extract_schema,
-                client=client,
-            ),
-            retry_decorator(retries),
-        )
-
-    def stream(
-        self,
-        retries: int | Retrying = 0,
-        client: Any | None = None,  # noqa: ANN401
-        **kwargs: Any,  # noqa: ANN401
-    ) -> Generator[_ExtractedTypeT, None, None]:
-        """Streams the desired structured output from the response."""
-        yield from self.run(
-            self.__class__._decorator(
-                self.call_params.model,
-                response_model=self.extract_schema,
-                stream=True,
-                client=client,
-            ),
-            retry_decorator(retries),
-        )
-
-    async def stream_async(
-        self,
-        retries: int | AsyncRetrying = 0,
-        client: Any | None = None,  # noqa: ANN401
-        **kwargs: Any,  # noqa: ANN401
-    ) -> AsyncGenerator[_ExtractedTypeT, None]:
-        """Asynchronously streams the desired structured output from the response."""
-        async for item in await self.run_async(
-            self.__class__._decorator(
-                self.call_params.model,
-                response_model=self.extract_schema,
-                stream=True,
-                client=client,
-            ),
-            retry_decorator(retries),
-        ):
-            yield item

mirascope/v0/base/ops_utils.py

@@ -1,207 +0,0 @@
-import inspect
-from collections.abc import Awaitable, Callable, Generator
-from contextlib import AbstractContextManager
-from functools import wraps
-from typing import Any, TypeVar
-
-from pydantic import BaseModel
-
-
-def get_class_vars(self: BaseModel) -> dict[str, Any]:
-    """Get the class variables of a `BaseModel` removing any dangerous variables."""
-    class_vars = {}
-    for classvars in self.__class_vars__:
-        if classvars != "api_key":
-            class_vars[classvars] = getattr(self.__class__, classvars)
-    return class_vars
-
-
-F = TypeVar("F", bound=Callable[..., Any])
-DecoratorType = Callable[[F], F]
-
-
-def mirascope_span(  # noqa: ANN201
-    fn: Callable,
-    *,
-    handle_before_call: Callable[..., Any] | None = None,
-    handle_before_call_async: Callable[..., Awaitable[Any]] | None = None,
-    handle_after_call: Callable[..., Any] | None = None,
-    handle_after_call_async: Callable[..., Awaitable[Any]] | None = None,
-    decorator: DecoratorType | None = None,
-    **custom_kwargs: Any,  # noqa: ANN401
-):
-    """Wraps a pydantic class method."""
-
-    async def run_after_call_handler(self, result, result_before_call, joined_kwargs):  # noqa: ANN001, ANN202
-        if handle_after_call_async is not None:
-            await handle_after_call_async(
-                self, fn, result, result_before_call, **joined_kwargs
-            )
-        elif handle_after_call is not None:
-            handle_after_call(self, fn, result, result_before_call, **joined_kwargs)
-
-    @wraps(fn)
-    def wrapper(self: BaseModel, *args: Any, **kwargs: Any):  # noqa: ANN202, ANN401
-        """Wraps a pydantic class method that returns a value."""
-        joined_kwargs = {**kwargs, **custom_kwargs}
-        before_call = (
-            handle_before_call(self, fn, **joined_kwargs)
-            if handle_before_call is not None
-            else None
-        )
-        if isinstance(before_call, AbstractContextManager):
-            with before_call as result_before_call:
-                result = fn(self, *args, **kwargs)
-                if handle_after_call is not None:
-                    handle_after_call(
-                        self, fn, result, result_before_call, **joined_kwargs
-                    )
-                return result
-        else:
-            result = fn(self, *args, **kwargs)
-            if handle_after_call is not None:
-                handle_after_call(self, fn, result, before_call, **joined_kwargs)
-            return result
-
-    @wraps(fn)
-    async def wrapper_async(self: BaseModel, *args: Any, **kwargs: Any):  # noqa: ANN202, ANN401
-        """Wraps a pydantic async class method that returns a value."""
-        joined_kwargs = {**kwargs, **custom_kwargs}
-        before_call = None
-        if handle_before_call_async is not None:
-            before_call = await handle_before_call_async(self, fn, **joined_kwargs)
-        elif handle_before_call is not None:
-            before_call = handle_before_call(self, fn, **joined_kwargs)
-
-        if isinstance(before_call, AbstractContextManager):
-            with before_call as result_before_call:
-                result = await fn(self, *args, **kwargs)
-                await run_after_call_handler(
-                    self, result, result_before_call, joined_kwargs
-                )
-                return result
-        else:
-            result = await fn(self, *args, **kwargs)
-            await run_after_call_handler(self, result, before_call, joined_kwargs)
-            return result
-
-    @wraps(fn)
-    def wrapper_generator(self: BaseModel, *args: Any, **kwargs: Any):  # noqa: ANN202, ANN401
-        """Wraps a pydantic class method that returns a generator."""
-        joined_kwargs = {**kwargs, **custom_kwargs}
-        before_call = (
-            handle_before_call(self, fn, **joined_kwargs)
-            if handle_before_call is not None
-            else None
-        )
-        if isinstance(before_call, AbstractContextManager):
-            with before_call as result_before_call:
-                result = fn(self, *args, **kwargs)
-                output = []
-                for value in result:
-                    output.append(value)
-                    yield value
-                if handle_after_call is not None:
-                    handle_after_call(
-                        self, fn, output, result_before_call, **joined_kwargs
-                    )
-        else:
-            result = fn(self, *args, **kwargs)
-            output = []
-            for value in result:
-                output.append(value)
-                yield value
-            if handle_after_call is not None:
-                handle_after_call(self, fn, output, before_call, **joined_kwargs)
-
-    @wraps(fn)
-    async def wrapper_generator_async(self: BaseModel, *args: Any, **kwargs: Any):  # noqa: ANN202, ANN401
-        """Wraps a pydantic async class method that returns a generator."""
-        joined_kwargs = {**kwargs, **custom_kwargs}
-        before_call = None
-        if handle_before_call_async is not None:
-            before_call = await handle_before_call_async(self, fn, **joined_kwargs)
-        elif handle_before_call is not None:
-            before_call = handle_before_call(self, fn, **joined_kwargs)
-        if isinstance(before_call, AbstractContextManager):
-            with before_call as result_before_call:
-                result = fn(self, *args, **kwargs)
-                output = []
-                async for value in result:
-                    output.append(value)
-                    yield value
-                await run_after_call_handler(
-                    self, output, result_before_call, joined_kwargs
-                )
-        else:
-            result = fn(self, *args, **kwargs)
-            output = []
-            async for value in result:
-                output.append(value)
-                yield value
-            await run_after_call_handler(self, output, before_call, joined_kwargs)
-
-    wrapper_function = wrapper
-    if inspect.isasyncgenfunction(fn):
-        wrapper_function = wrapper_generator_async
-    elif inspect.iscoroutinefunction(fn):
-        wrapper_function = wrapper_async
-    elif inspect.isgeneratorfunction(fn):
-        wrapper_function = wrapper_generator
-    if decorator is not None:
-        wrapper_function = decorator(wrapper_function)
-    return wrapper_function
-
-
-def wrap_mirascope_class_functions(  # noqa: ANN201
-    cls: type[BaseModel],
-    *,
-    handle_before_call: Callable[..., Any] | None = None,
-    handle_before_call_async: Callable[..., Awaitable[Any]] | None = None,
-    handle_after_call: Callable[..., Any] | None = None,
-    handle_after_call_async: Callable[..., Awaitable[Any]] | None = None,
-    decorator: DecoratorType | None = None,
-    **custom_kwargs: Any,  # noqa: ANN401
-):
-    """Wraps Mirascope class functions with a decorator.
-
-    Args:
-        cls: The Mirascope class to wrap.
-        handle_before_call: A function to call before the call to the wrapped function.
-        handle_after_call: A function to call after the call to the wrapped function.
-        custom_kwargs: Additional keyword arguments to pass to the decorator.
-    """
-
-    for name in get_class_functions(cls):
-        setattr(
-            cls,
-            name,
-            mirascope_span(
-                getattr(cls, name),
-                handle_before_call=handle_before_call,
-                handle_before_call_async=handle_before_call_async,
-                handle_after_call=handle_after_call,
-                handle_after_call_async=handle_after_call_async,
-                decorator=decorator,
-                **custom_kwargs,
-            ),
-        )
-    return cls
-
-
-def get_class_functions(cls: type[BaseModel]) -> Generator[str, None, None]:
-    """Get the class functions of a `BaseModel`."""
-    ignore_functions = [
-        "copy",
-        "dict",
-        "dump",
-        "json",
-        "messages",
-        "model_copy",
-        "model_dump",
-        "model_dump_json",
-        "model_post_init",
-    ]
-    for name, _ in inspect.getmembers(cls, predicate=inspect.isfunction):
-        if not name.startswith("_") and name not in ignore_functions:
-            yield name

mirascope/v0/base/prompts.py

@@ -1,48 +0,0 @@
-from collections.abc import Callable
-from typing import TypeVar
-
-from .calls import BaseCall
-
-_BaseCallT = TypeVar("_BaseCallT", bound=BaseCall)
-
-
-def tags(args: list[str]) -> Callable[[type[_BaseCallT]], type[_BaseCallT]]:
-    '''A decorator for adding tags to a `BasePrompt`.
-
-    Adding this decorator to a `BasePrompt` updates the `_tags` class attribute to the
-    given value. This is useful for adding metadata to a `BasePrompt` that can be used
-    for logging or filtering.
-
-    Example:
-
-    ```python
-    from mirascope import BasePrompt, tags
-
-
-    @tags(["book_recommendation", "entertainment"])
-    class BookRecommendationPrompt(BasePrompt):
-        prompt_template = """
-        SYSTEM:
-        You are the world's greatest librarian.
-
-        USER:
-        I've recently read this book: {book_title}.
-        What should I read next?
-        """
-
-        book_title: [str]
-
-    print(BookRecommendationPrompt.dump()["tags"])
-    #> ['book_recommendation', 'entertainment']
-    ```
-
-    Returns:
-        The decorated class with `tags` class attribute set.
-    '''
-
-    def tags_fn(model_class: type[_BaseCallT]) -> type[_BaseCallT]:
-        """Updates the `tags` class attribute to the given value."""
-        model_class.tags = args
-        return model_class
-
-    return tags_fn

mirascope/v0/base/types.py

@@ -1,14 +0,0 @@
-from collections.abc import Callable
-
-from pydantic import BaseModel, ConfigDict
-
-from ...core.base import BaseTool
-
-
-class BaseCallParams(BaseModel):
-    """The parameters with which to make a call."""
-
-    model: str
-    tools: list[type[BaseTool] | Callable] | None = None
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)

mirascope/v0/base/utils.py

@@ -1,21 +0,0 @@
-from collections.abc import Callable
-
-from tenacity import AsyncRetrying, Retrying, retry, stop_after_attempt
-
-
-def retry_decorator(retries: int | Retrying | AsyncRetrying) -> Callable:
-    if isinstance(retries, int):
-        if retries == 0:
-            return lambda x: x
-        return retry(stop=stop_after_attempt(retries))
-    return retry(
-        sleep=retries.sleep,
-        stop=retries.stop,
-        wait=retries.wait,
-        before=retries.before,
-        after=retries.after,
-        before_sleep=retries.before_sleep,
-        reraise=retries.reraise,
-        retry_error_cls=retries.retry_error_cls,
-        retry_error_callback=retries.retry_error_callback,
-    )