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

mirascope/beta/openai/realtime/tool.py

@@ -1,113 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Literal
-
-import jiter
-from pydantic.json_schema import SkipJsonSchema
-from typing_extensions import NotRequired, TypedDict
-
-from ....core import BaseTool
-from ....core.base import GenerateJsonSchemaNoTitles, ToolConfig
-
-
-class OpenAIRealtimeToolConfig(ToolConfig, total=False):
-    """A tool configuration for OpenAI-specific features."""
-
-
-class RealtimeToolParam(TypedDict, total=False):
-    type: Literal["function"]
-    """The type of the tool."""
-
-    name: str
-    """The name of the function."""
-
-    description: str
-    """The description of the function."""
-
-    parameters: NotRequired[dict[str, Any]]
-    """Parameters of the function in JSON Schema."""
-
-
-class FunctionCallArguments(TypedDict, total=False):
-    call_id: str
-    """The ID of the function call."""
-
-    arguments: str
-    """The arguments that the model called."""
-
-
-class OpenAIRealtimeTool(BaseTool):
-    """A class for defining tools for OpenAI Realtime LLM calls.
-
-    Example:
-
-    ```python
-    from mirascope.beta.openai import Realtime, OpenAIRealtimeTool, Context
-
-    app = Realtime(
-        "gpt-4o-realtime-preview-2024-10-01",
-        modalities=["text"],
-    )
-
-    def format_book(title: str, author: str) -> str:
-        return f"{title} by {author}"
-
-    @app.sender(wait_for_text_response=True, tools=[format_book])
-    async def send_genre(context: Context) -> str:
-        genre = await async_input("Enter a genre: ")
-        return f"Recommend a {genre} book"
-
-    @app.receiver("text")
-    async def receive_text(response: str, context: dict[str, Any]) -> None:
-        print(f"AI(text): {response}", flush=True)
-
-    @app.receiver("tool")
-    def recommend_book(response: OpenAIRealtimeTool, context: Context) -> None:
-        print(response.call())
-    ```
-    """
-
-    __provider__ = "openai"
-    __tool_config_type__ = OpenAIRealtimeToolConfig
-
-    tool_call: SkipJsonSchema[FunctionCallArguments]
-
-    @classmethod
-    def tool_schema(cls) -> RealtimeToolParam:
-        """Constructs a JSON Schema tool schema from the `BaseModel` schema defined.
-
-        Example:
-        ```python
-        from mirascope.beta.openai import OpenAITool
-
-
-        def format_book(title: str, author: str) -> str:
-            return f"{title} by {author}"
-
-
-        tool_type = OpenAIRealtimeTool.type_from_fn(format_book)
-        print(tool_type.tool_schema())  # prints the OpenAI-specific tool schema
-        ```
-        """
-
-        tool = RealtimeToolParam(
-            name=cls._name(), description=cls._description(), type="function"
-        )
-        model_schema = cls.model_json_schema(
-            schema_generator=GenerateJsonSchemaNoTitles
-        )
-        if model_schema["properties"]:
-            tool["parameters"] = model_schema
-        return tool
-
-    @classmethod
-    def from_tool_call(cls, tool_call: FunctionCallArguments) -> OpenAIRealtimeTool:
-        """Constructs an `OpenAITool` instance from a `tool_call`.
-
-        Args:
-            tool_call: The OpenAI tool call from which to construct this tool instance.
-        """
-        model_json = {"tool_call": tool_call.copy()}
-        if args := tool_call.get("arguments", None):
-            model_json |= jiter.from_json(args.encode())
-        return cls.model_validate(model_json)

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",
-    "BaseEmbedder",
-    "BaseEmbeddingParams",
-    "BaseEmbeddingResponse",
-    "BaseQueryResults",
-    "BaseVectorStore",
-    "BaseVectorStoreParams",
-    "Document",
-    "TextChunker",
-]

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",
-    "BaseEmbedder",
-    "BaseEmbeddingParams",
-    "BaseEmbeddingResponse",
-    "BaseQueryResults",
-    "BaseVectorStore",
-    "BaseVectorStoreParams",
-    "Document",
-    "TextChunker",
-]

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

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",
-]

mirascope/beta/rag/cohere/embedders.py

@@ -1,87 +0,0 @@
-"""A module for calling OpenAI's Embeddings models."""
-
-import datetime
-from typing import ClassVar
-
-from cohere import AsyncClient, Client
-
-from ..base.embedders import BaseEmbedder
-from .embedding_params import CohereEmbeddingParams
-from .embedding_response import CohereEmbeddingResponse
-
-
-class CohereEmbedder(BaseEmbedder[CohereEmbeddingResponse]):
-    """Cohere Embedder
-
-    model                           max_dimensions
-    embed-english-v3.0              1024
-    embed-multilingual-v3.0         1024
-    embed-english-light-v3.0        384
-    embed-multilingual-light-v3.0   384
-    embed-english-v2.0              4096
-    embed-english-light-v2.0        1024
-    embed-multilingual-v2.0         768
-
-    Example:
-
-    ```python
-    import os
-    from mirascope.beta.rag.cohere import CohereEmbedder
-
-    os.environ["CO_API_KEY"] = "YOUR_COHERE_API_KEY"
-
-    cohere_embedder = CohereEmbedder()
-    response = cohere_embedder.embed(["your text to embed"])
-    print(response)
-    ```
-    """
-
-    dimensions: int | None = 1024
-    embedding_params: ClassVar[CohereEmbeddingParams] = CohereEmbeddingParams(
-        model="embed-english-v3.0"
-    )
-    _provider: ClassVar[str] = "cohere"
-
-    def embed(self, inputs: list[str]) -> CohereEmbeddingResponse:
-        """Call the embedder with multiple inputs"""
-
-        co = Client(api_key=self.api_key, base_url=self.base_url)
-        embedding_type = (
-            self.embedding_params.embedding_types[0]
-            if self.embedding_params.embedding_types
-            else None
-        )
-        start_time = datetime.datetime.now().timestamp() * 1000
-        response = co.embed(texts=inputs, **self.embedding_params.kwargs())
-        return CohereEmbeddingResponse(
-            response=response,
-            start_time=start_time,
-            end_time=datetime.datetime.now().timestamp() * 1000,
-            embedding_type=embedding_type,
-        )
-
-    async def embed_async(self, inputs: list[str]) -> CohereEmbeddingResponse:
-        """Asynchronously call the embedder with multiple inputs"""
-        co = AsyncClient(api_key=self.api_key, base_url=self.base_url)
-        embedding_type = (
-            self.embedding_params.embedding_types[0]
-            if self.embedding_params.embedding_types
-            else None
-        )
-        start_time = datetime.datetime.now().timestamp() * 1000
-        response = await co.embed(texts=inputs, **self.embedding_params.kwargs())
-        return CohereEmbeddingResponse(
-            response=response,
-            start_time=start_time,
-            end_time=datetime.datetime.now().timestamp() * 1000,
-            embedding_type=embedding_type,
-        )
-
-    def __call__(self, input: list[str]) -> list[list[float]] | list[list[int]] | None:
-        """Call the embedder with a input
-
-        Chroma expects parameter to be `input`.
-        """
-        response = self.embed(input)
-        embeddings = response.embeddings
-        return embeddings