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

mirascope/beta/openai/parse.py

@@ -1,129 +0,0 @@
-"""Beta implementation of the new OpenAI parse functionality."""
-
-import inspect
-from collections.abc import Awaitable, Callable
-from functools import wraps
-from typing import Literal, ParamSpec, Protocol, TypeVar, cast, overload
-
-from openai import AsyncOpenAI, OpenAI
-from openai.types.chat import ChatCompletionMessageParam
-from pydantic import BaseModel
-
-from mirascope.core.base import BaseMessageParam, _utils
-from mirascope.core.openai import OpenAICallParams, OpenAIDynamicConfig, OpenAITool
-from mirascope.core.openai._utils import convert_message_params
-
-_ResponseModelT = TypeVar("_ResponseModelT", bound=_utils.BaseType | BaseModel)
-_P = ParamSpec("_P")
-
-
-class ParseFunctionDecorator(Protocol[_ResponseModelT]):
-    @overload
-    def __call__(self, fn: Callable[..., OpenAIDynamicConfig]) -> _ResponseModelT: ...
-
-    @overload
-    def __call__(
-        self, fn: Callable[..., Awaitable[OpenAIDynamicConfig]]
-    ) -> Awaitable[_ResponseModelT]: ...
-
-    def __call__(
-        self, fn: Callable[..., OpenAIDynamicConfig | Awaitable[OpenAIDynamicConfig]]
-    ) -> _ResponseModelT | Awaitable[_ResponseModelT]: ...
-
-
-def parse(
-    model: Literal["gpt-4o-2024-08-06"],
-    response_model: type[_ResponseModelT],
-    call_params: OpenAICallParams | None = None,
-) -> ParseFunctionDecorator[_ResponseModelT]:
-    """Beta implementation of the new OpenAI parse functionality."""
-
-    @overload
-    def decorator(
-        fn: Callable[_P, OpenAIDynamicConfig],
-    ) -> Callable[_P, _ResponseModelT]: ...
-
-    @overload
-    def decorator(
-        fn: Callable[_P, Awaitable[OpenAIDynamicConfig]],
-    ) -> Callable[_P, Awaitable[_ResponseModelT]]: ...
-
-    def decorator(
-        fn: Callable[_P, OpenAIDynamicConfig | Awaitable[OpenAIDynamicConfig]],
-    ):
-        if inspect.iscoroutinefunction(fn):
-
-            @wraps(fn)
-            async def inner_async(
-                *args: _P.args, **kwargs: _P.kwargs
-            ) -> _ResponseModelT:
-                assert _utils.SetupCall.fn_is_async(fn)
-                fn_args = _utils.get_fn_args(fn, args, kwargs)
-                dynamic_config = await fn(*args, **kwargs)
-                _, messages, _, call_kwargs = _utils.setup_call(
-                    fn,
-                    fn_args,
-                    dynamic_config,
-                    None,
-                    OpenAITool,
-                    call_params or OpenAICallParams(),
-                )
-                messages = cast(
-                    list[BaseMessageParam | ChatCompletionMessageParam], messages
-                )
-                messages = convert_message_params(messages)
-                messages.append(
-                    {"role": "user", "content": _utils.json_mode_content(None)}
-                )
-                client = AsyncOpenAI()
-                call_kwargs.pop("response_format", None)
-                completion = await client.beta.chat.completions.parse(
-                    model=model,
-                    messages=messages,
-                    response_format=response_model,
-                    **call_kwargs,
-                )
-                message = completion.choices[0].message
-                if message.parsed:
-                    return message.parsed
-                raise RuntimeError(f"{message.refusal}")
-
-            return inner_async
-        else:
-
-            @wraps(fn)
-            def inner(*args: _P.args, **kwargs: _P.kwargs) -> _ResponseModelT:
-                assert _utils.SetupCall.fn_is_sync(fn)
-                fn_args = _utils.get_fn_args(fn, args, kwargs)
-                dynamic_config = fn(*args, **kwargs)
-                _, messages, _, call_kwargs = _utils.setup_call(
-                    fn,
-                    fn_args,
-                    dynamic_config,
-                    None,
-                    OpenAITool,
-                    call_params or OpenAICallParams(),
-                )
-                messages = cast(
-                    list[BaseMessageParam | ChatCompletionMessageParam], messages
-                )
-                messages = convert_message_params(messages)
-                messages.append(
-                    {"role": "user", "content": _utils.json_mode_content(None)}
-                )
-                client = OpenAI()
-                call_kwargs.pop("response_format", None)
-                completion = client.beta.chat.completions.parse(
-                    model=model,
-                    messages=messages,
-                    response_format=response_model,
-                    **call_kwargs,
-                )
-                message = completion.choices[0].message
-                if message.parsed:
-                    return message.parsed
-                raise RuntimeError(f"{message.refusal}")
-
-            return inner
-
-    return decorator

mirascope/beta/rag/__init__.py

@@ -1,24 +0,0 @@
-"""A module for interacting with Mirascope RAG."""
-
-from .base import (
-    BaseChunker,
-    BaseEmbedder,
-    BaseEmbeddingParams,
-    BaseEmbeddingResponse,
-    BaseQueryResults,
-    BaseVectorStore,
-    BaseVectorStoreParams,
-    Document,
-)
-
-__all__ = [
-    "BaseChunker",
-    "TextChunker",
-    "BaseEmbedder",
-    "BaseEmbeddingParams",
-    "BaseEmbeddingResponse",
-    "BaseQueryResults",
-    "BaseVectorStoreParams",
-    "BaseVectorStore",
-    "Document",
-]

mirascope/beta/rag/base/__init__.py

@@ -1,22 +0,0 @@
-"""A module for interacting with Mirascope RAG."""
-
-from .chunkers import BaseChunker, TextChunker
-from .document import Document
-from .embedders import BaseEmbedder
-from .embedding_params import BaseEmbeddingParams
-from .embedding_response import BaseEmbeddingResponse
-from .query_results import BaseQueryResults
-from .vectorstore_params import BaseVectorStoreParams
-from .vectorstores import BaseVectorStore
-
-__all__ = [
-    "BaseChunker",
-    "TextChunker",
-    "BaseEmbedder",
-    "BaseEmbeddingParams",
-    "BaseEmbeddingResponse",
-    "BaseQueryResults",
-    "BaseVectorStoreParams",
-    "BaseVectorStore",
-    "Document",
-]

mirascope/beta/rag/base/chunkers/__init__.py

@@ -1,2 +0,0 @@
-from .base_chunker import BaseChunker
-from .text_chunker import TextChunker

mirascope/beta/rag/base/chunkers/base_chunker.py

@@ -1,37 +0,0 @@
-"""Chunkers for the RAG module."""
-
-from abc import ABC, abstractmethod
-
-from pydantic import BaseModel
-
-from ..document import Document
-
-
-class BaseChunker(BaseModel, ABC):
-    """Base class for chunkers.
-
-    Example:
-
-    ```python
-    from mirascope.rag import BaseChunker, Document
-
-
-    class TextChunker(BaseChunker):
-        chunk_size: int
-        chunk_overlap: int
-
-        def chunk(self, text: str) -> list[Document]:
-            chunks: list[Document] = []
-            start: int = 0
-            while start < len(text):
-                end: int = min(start + self.chunk_size, len(text))
-                chunks.append(Document(text=text[start:end], id=str(uuid.uuid4())))
-                start += self.chunk_size - self.chunk_overlap
-            return chunks
-    ```
-    """
-
-    @abstractmethod
-    def chunk(self, text: str) -> list[Document]:
-        """Returns a Document that contains an id, text, and optionally metadata."""
-        ...

mirascope/beta/rag/base/chunkers/text_chunker.py

@@ -1,33 +0,0 @@
-"""Text chunker for the RAG module"""
-
-import uuid
-
-from ..document import Document
-from .base_chunker import BaseChunker
-
-
-class TextChunker(BaseChunker):
-    """A text chunker that splits a text into chunks of a certain size and overlaps.
-
-    Example:
-
-    ```python
-    from mirascope.rag import TextChunker
-
-    text_chunker = TextChunker(chunk_size=1000, chunk_overlap=200)
-    chunks = text_chunker.chunk("This is a long text that I want to split into chunks.")
-    print(chunks)
-    ```
-    """
-
-    chunk_size: int
-    chunk_overlap: int
-
-    def chunk(self, text: str) -> list[Document]:
-        chunks: list[Document] = []
-        start: int = 0
-        while start < len(text):
-            end: int = min(start + self.chunk_size, len(text))
-            chunks.append(Document(text=text[start:end], id=str(uuid.uuid4())))
-            start += self.chunk_size - self.chunk_overlap
-        return chunks

mirascope/beta/rag/base/config.py

@@ -1,8 +0,0 @@
-from collections.abc import Callable
-
-from pydantic import BaseModel
-
-
-class BaseConfig(BaseModel):
-    llm_ops: list[Callable | str] = []
-    client_wrappers: list[Callable | str] = []

mirascope/beta/rag/base/document.py

@@ -1,11 +0,0 @@
-from typing import Any
-
-from pydantic import BaseModel
-
-
-class Document(BaseModel):
-    """A document to be added to the vectorstore."""
-
-    id: str
-    text: str
-    metadata: dict[str, Any] | None = None

mirascope/beta/rag/base/embedders.py

@@ -1,35 +0,0 @@
-"""Embedders for the RAG module."""
-
-from abc import ABC, abstractmethod
-from typing import ClassVar, Generic, TypeVar
-
-from pydantic import BaseModel
-
-from .config import BaseConfig
-from .embedding_params import BaseEmbeddingParams
-from .embedding_response import BaseEmbeddingResponse
-
-BaseEmbeddingT = TypeVar("BaseEmbeddingT", bound=BaseEmbeddingResponse)
-
-
-class BaseEmbedder(BaseModel, Generic[BaseEmbeddingT], ABC):
-    """The base class abstract interface for interacting with LLM embeddings."""
-
-    api_key: ClassVar[str | None] = None
-    base_url: ClassVar[str | None] = None
-    embedding_params: ClassVar[BaseEmbeddingParams] = BaseEmbeddingParams(
-        model="text-embedding-ada-002"
-    )
-    dimensions: int | None = None
-    configuration: ClassVar[BaseConfig] = BaseConfig(llm_ops=[], client_wrappers=[])
-    _provider: ClassVar[str] = "base"
-
-    @abstractmethod
-    def embed(self, input: list[str]) -> BaseEmbeddingT:
-        """A call to the embedder with a single input"""
-        ...
-
-    @abstractmethod
-    async def embed_async(self, input: list[str]) -> BaseEmbeddingT:
-        """Asynchronously call the embedder with a single input"""
-        ...

mirascope/beta/rag/base/embedding_params.py

@@ -1,18 +0,0 @@
-from typing import Any
-
-from pydantic import BaseModel, ConfigDict
-
-
-class BaseEmbeddingParams(BaseModel):
-    """The parameters with which to make an embedding."""
-
-    model: str
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
-
-    def kwargs(self) -> dict[str, Any]:
-        """Returns all parameters for the embedder as a keyword arguments dictionary."""
-        kwargs = {
-            key: value for key, value in self.model_dump().items() if value is not None
-        }
-        return kwargs

mirascope/beta/rag/base/embedding_response.py

@@ -1,30 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Generic, TypeVar
-
-from pydantic import BaseModel, ConfigDict
-
-ResponseT = TypeVar("ResponseT", bound=Any)
-
-
-class BaseEmbeddingResponse(BaseModel, Generic[ResponseT], ABC):
-    """A base abstract interface for LLM embedding responses.
-
-    Attributes:
-        response: The original response from whichever model response this wraps.
-    """
-
-    response: ResponseT
-    start_time: float  # The start time of the embedding in ms
-    end_time: float  # The end time of the embedding in ms
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
-
-    @property
-    @abstractmethod
-    def embeddings(self) -> list[list[float]] | list[list[int]] | None:
-        """Should return the embedding of the response.
-
-        If there are multiple choices in a response, this method should select the 0th
-        choice and return it's embedding.
-        """
-        ...

mirascope/beta/rag/base/query_results.py

@@ -1,7 +0,0 @@
-from pydantic import BaseModel, ConfigDict
-
-
-class BaseQueryResults(BaseModel):
-    """The results of a query."""
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)

mirascope/beta/rag/base/vectorstore_params.py

@@ -1,18 +0,0 @@
-from typing import Any
-
-from pydantic import BaseModel, ConfigDict
-
-
-class BaseVectorStoreParams(BaseModel):
-    """The parameters with which to make a vectorstore."""
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
-
-    def kwargs(
-        self,
-    ) -> dict[str, Any]:
-        """Returns all parameters for the index as a keyword arguments dictionary."""
-        kwargs = {
-            key: value for key, value in self.model_dump().items() if value is not None
-        }
-        return kwargs

mirascope/beta/rag/base/vectorstores.py

@@ -1,37 +0,0 @@
-"""Vectorstores for the RAG module."""
-
-from abc import ABC, abstractmethod
-from typing import Any, ClassVar, Generic, TypeVar
-
-from pydantic import BaseModel
-
-from .chunkers import BaseChunker, TextChunker
-from .config import BaseConfig
-from .document import Document
-from .embedders import BaseEmbedder
-from .query_results import BaseQueryResults
-from .vectorstore_params import BaseVectorStoreParams
-
-BaseQueryResultsT = TypeVar("BaseQueryResultsT", bound=BaseQueryResults)
-
-
-class BaseVectorStore(BaseModel, Generic[BaseQueryResultsT], ABC):
-    """The base class abstract interface for interacting with vectorstores."""
-
-    api_key: ClassVar[str | None] = None
-    index_name: ClassVar[str | None] = None
-    chunker: ClassVar[BaseChunker] = TextChunker(chunk_size=1000, chunk_overlap=200)
-    embedder: ClassVar[BaseEmbedder]
-    vectorstore_params: ClassVar[BaseVectorStoreParams] = BaseVectorStoreParams()
-    configuration: ClassVar[BaseConfig] = BaseConfig()
-    _provider: ClassVar[str] = "base"
-
-    @abstractmethod
-    def retrieve(self, text: str, **kwargs: Any) -> BaseQueryResultsT:  # noqa: ANN401
-        """Queries the vectorstore for closest match"""
-        ...
-
-    @abstractmethod
-    def add(self, text: str | list[Document], **kwargs: Any) -> None:  # noqa: ANN401
-        """Takes unstructured data and upserts into vectorstore"""
-        ...

mirascope/beta/rag/chroma/__init__.py

@@ -1,11 +0,0 @@
-"""A module for interacting with Chroma vectorstores."""
-
-from .types import ChromaParams, ChromaQueryResult, ChromaSettings
-from .vectorstores import ChromaVectorStore
-
-__all__ = [
-    "ChromaParams",
-    "ChromaQueryResult",
-    "ChromaSettings",
-    "ChromaVectorStore",
-]

mirascope/beta/rag/chroma/types.py

@@ -1,57 +0,0 @@
-"""Types for interacting with Chroma using Mirascope."""
-
-from typing import Any, Literal
-
-from chromadb import CollectionMetadata, Settings
-from chromadb.api.types import URI, Document, IDs, Loadable, Metadata
-from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT
-from chromadb.types import Vector
-from pydantic import BaseModel, ConfigDict
-
-from ..base.vectorstore_params import BaseVectorStoreParams
-
-
-class ChromaParams(BaseVectorStoreParams):
-    metadata: CollectionMetadata | None = None
-    get_or_create: bool = False
-
-
-class ChromaQueryResult(BaseModel):
-    ids: list[IDs]
-    embeddings: list[list[Vector]] | None = None
-    documents: list[list[Document]] | None = None
-    uris: list[list[URI]] | None = None
-    data: list[Loadable] | None = None
-    metadatas: list[list[Metadata | None]] | None = None
-    distances: list[list[float]] | None = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class ChromaSettings(BaseModel):
-    mode: Literal["http", "persistent", "ephemeral"] = "persistent"
-    path: str = "./chroma"
-    host: str = "localhost"
-    port: int = 8000
-    ssl: bool = False
-    headers: dict[str, str] | None = None
-    settings: Settings | None = None
-    tenant: str = DEFAULT_TENANT
-    database: str = DEFAULT_DATABASE
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
-
-    def kwargs(self) -> dict[str, Any]:
-        """Returns all parameters for the index as a keyword arguments dictionary."""
-        if self.mode == "http":
-            exclude = {"mode", "path"}
-        elif self.mode == "persistent":
-            exclude = {"mode", "host", "port", "ssl", "headers"}
-        elif self.mode == "ephemeral":
-            exclude = {"mode", "host", "port", "ssl", "headers", "path"}
-        kwargs = {
-            key: value
-            for key, value in self.model_dump(exclude=exclude).items()
-            if value is not None
-        }
-        return kwargs

mirascope/beta/rag/chroma/vectorstores.py

@@ -1,97 +0,0 @@
-"""A module for calling Chroma's Client and Collection."""
-
-from functools import cached_property
-from typing import Any, ClassVar, cast
-
-from chromadb import Collection, EphemeralClient, HttpClient, Metadata, PersistentClient
-from chromadb.api import ClientAPI
-
-from ..base.document import Document
-from ..base.vectorstores import BaseVectorStore
-from .types import ChromaParams, ChromaQueryResult, ChromaSettings
-
-
-class ChromaVectorStore(BaseVectorStore):
-    """A vectorstore for Chroma.
-
-    Example:
-
-    ```python
-    from mirascope.beta.rag.chroma import ChromaSettings, ChromaVectorStore
-    from mirascope.beta.rag.openai import OpenAIEmbedder
-    from mirascope.beta.rag import TextChunker
-
-
-    class MyStore(ChromaVectorStore):
-        embedder = OpenAIEmbedder()
-        chunker = TextChunker(chunk_size=1000, chunk_overlap=200)
-        index_name = "my-store-0001"
-        client_settings = ChromaSettings()
-
-    my_store = MyStore()
-    with open(f"{PATH_TO_FILE}") as file:
-        data = file.read()
-        my_store.add(data)
-    documents = my_store.retrieve("my question").documents
-    print(documents)
-    ```
-    """
-
-    vectorstore_params = ChromaParams(get_or_create=True)
-    client_settings: ClassVar[ChromaSettings] = ChromaSettings(mode="persistent")
-    _provider: ClassVar[str] = "chroma"
-
-    def retrieve(
-        self,
-        text: str | list[str] | None = None,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> ChromaQueryResult:
-        """Queries the vectorstore for closest match"""
-        if text:
-            if isinstance(text, str):
-                text = [text]
-            query_result = self._index.query(query_texts=text, **kwargs)
-        else:
-            query_result = self._index.query(**kwargs)
-
-        return ChromaQueryResult.model_validate(query_result)
-
-    def add(self, text: str | list[Document], **kwargs: Any) -> None:  # noqa: ANN401
-        """Takes unstructured data and upserts into vectorstore"""
-        documents: list[Document]
-        if isinstance(text, str):
-            chunk = self.chunker.chunk
-            documents = chunk(text)
-        else:
-            documents = text
-
-        return self._index.upsert(
-            ids=[document.id for document in documents],
-            documents=[document.text for document in documents],
-            metadatas=[cast(Metadata, document.metadata) for document in documents],
-            **kwargs,
-        )
-
-    ############################# PRIVATE PROPERTIES #################################
-
-    @cached_property
-    def _client(self) -> ClientAPI:
-        if self.client_settings.mode == "persistent":
-            return PersistentClient(**self.client_settings.kwargs())
-        elif self.client_settings.mode == "http":
-            return HttpClient(**self.client_settings.kwargs())
-        elif self.client_settings.mode == "ephemeral":
-            return EphemeralClient(**self.client_settings.kwargs())
-
-    @cached_property
-    def _index(self) -> Collection:
-        vectorstore_params = self.vectorstore_params
-        if self.index_name:
-            vectorstore_params = self.vectorstore_params.model_copy(
-                update={"name": self.index_name}
-            )
-
-        return self._client.create_collection(
-            **vectorstore_params.kwargs(),
-            embedding_function=self.embedder,  # type: ignore
-        )

mirascope/beta/rag/cohere/__init__.py

@@ -1,11 +0,0 @@
-"""A module for interacting with Cohere chat models."""
-
-from .embedders import CohereEmbedder
-from .embedding_params import CohereEmbeddingParams
-from .embedding_response import CohereEmbeddingResponse
-
-__all__ = [
-    "CohereEmbedder",
-    "CohereEmbeddingParams",
-    "CohereEmbeddingResponse",
-]