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

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,
-    )

mirascope/v0/openai.py

@@ -1,54 +0,0 @@
-"""OpenAI modules for the v0 look-alike implementation."""
-
-from typing import ClassVar, Generic, TypeVar
-
-from openai.types.chat import ChatCompletionToolChoiceOptionParam
-from openai.types.chat.completion_create_params import ResponseFormat
-from pydantic import ConfigDict
-
-from ..core.openai import (
-    OpenAICallResponse,
-    OpenAICallResponseChunk,
-    OpenAITool,
-    openai_call,
-)
-from .base import BaseCall, BaseCallParams, BaseExtractor, ExtractedType
-
-
-class OpenAICallParams(BaseCallParams):
-    """The parameters to use when calling the OpenAI API."""
-
-    model: str
-    frequency_penalty: float | None = None
-    logit_bias: dict[str, int] | None = None
-    logprobs: bool | None = None
-    max_tokens: int | None = None
-    n: int | None = None
-    presence_penalty: float | None = None
-    response_format: ResponseFormat | None = None
-    seed: int | None = None
-    stop: str | list[str] | None = None
-    temperature: float | None = None
-    tool_choice: ChatCompletionToolChoiceOptionParam | None = None
-    top_logprobs: int | None = None
-    top_p: float | None = None
-    user: str | None = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
-
-
-class OpenAICall(BaseCall[OpenAICallResponse, OpenAICallResponseChunk, OpenAITool]):
-    call_params: ClassVar[BaseCallParams] = OpenAICallParams(model="gpt-4o-mini")
-
-    _decorator = openai_call
-    _provider = "openai"
-
-
-T = TypeVar("T", bound=ExtractedType)
-
-
-class OpenAIExtractor(BaseExtractor[T], Generic[T]):
-    call_params: ClassVar[BaseCallParams] = OpenAICallParams(model="gpt-4o-mini")
-
-    _decorator = openai_call
-    _provider = "openai"