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

mirascope/beta/rag/cohere/embedding_params.py

@@ -1,29 +0,0 @@
-from collections.abc import Sequence
-from typing import Any, Literal, NotRequired
-
-from typing_extensions import TypedDict
-
-from ..base.embedding_params import BaseEmbeddingParams
-
-
-class RequestOptions(TypedDict):
-    """Redefining their class to use `typing_extensions.TypedDict` for Pydantic."""
-
-    timeout_in_seconds: NotRequired[int]
-    max_retries: NotRequired[int]
-    additional_headers: NotRequired[dict[str, Any]]
-    additional_query_parameters: NotRequired[dict[str, Any]]
-    additional_body_parameters: NotRequired[dict[str, Any]]
-
-
-class CohereEmbeddingParams(BaseEmbeddingParams):
-    model: str = "embed-english-v3.0"
-    input_type: Literal[
-        "search_document", "search_query", "classification", "clustering"
-    ] = "search_query"
-    embedding_types: (
-        Sequence[Literal["float", "int8", "uint8", "binary", "ubinary"]] | None
-    ) = None
-    truncate: Literal["none", "end", "start"] | None = "end"
-    request_options: RequestOptions | None = None
-    batching: bool | None = True

mirascope/beta/rag/cohere/embedding_response.py

@@ -1,29 +0,0 @@
-from typing import Literal
-
-from cohere.types import EmbedByTypeResponseEmbeddings, EmbedResponse
-from pydantic import SkipValidation
-
-from ..base.embedding_response import BaseEmbeddingResponse
-
-
-class CohereEmbeddingResponse(BaseEmbeddingResponse[SkipValidation[EmbedResponse]]):
-    """A convenience wrapper around the Cohere `EmbedResponse` response."""
-
-    embedding_type: Literal["float", "int8", "uint8", "binary", "ubinary"] | None = None
-
-    @property
-    def embeddings(
-        self,
-    ) -> list[list[float]] | list[list[int]] | None:
-        """Returns the embeddings"""
-        if self.response.response_type == "embeddings_floats":
-            return self.response.embeddings
-        else:
-            embedding_type = self.embedding_type
-            if embedding_type == "float":
-                embedding_type = "float_"
-
-            # TODO: Update to model_dump when Cohere updates to Pydantic v2
-            embeddings_by_type: EmbedByTypeResponseEmbeddings = self.response.embeddings
-            embedding_dict = embeddings_by_type.dict()
-            return embedding_dict.get(str(embedding_type), None)

mirascope/beta/rag/openai/__init__.py

@@ -1,11 +0,0 @@
-"""A module for interacting with OpenAI models."""
-
-from .embedders import OpenAIEmbedder
-from .embedding_params import OpenAIEmbeddingParams
-from .embedding_response import OpenAIEmbeddingResponse
-
-__all__ = [
-    "OpenAIEmbedder",
-    "OpenAIEmbeddingParams",
-    "OpenAIEmbeddingResponse",
-]

mirascope/beta/rag/openai/embedders.py

@@ -1,144 +0,0 @@
-"""A module for calling OpenAI's Embeddings models."""
-
-import asyncio
-import datetime
-from concurrent.futures import ThreadPoolExecutor
-from typing import ClassVar
-
-from openai import AsyncOpenAI, OpenAI
-from openai.types import Embedding
-from openai.types.create_embedding_response import CreateEmbeddingResponse, Usage
-
-from ..base.embedders import BaseEmbedder
-from .embedding_params import OpenAIEmbeddingParams
-from .embedding_response import OpenAIEmbeddingResponse
-
-
-class OpenAIEmbedder(BaseEmbedder[OpenAIEmbeddingResponse]):
-    """OpenAI Embedder
-
-    Example:
-
-    ```python
-    import os
-    from mirascope.beta.rag.openai import OpenAIEmbedder
-
-    os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
-
-    openai_embedder = OpenAIEmbedder()
-    response = openai_embedder.embed(["your text to embed"])
-    print(response)
-    ```
-    """
-
-    dimensions: int | None = 1536
-    embed_batch_size: int | None = 20
-    max_workers: int | None = 64
-    embedding_params: ClassVar[OpenAIEmbeddingParams] = OpenAIEmbeddingParams(
-        model="text-embedding-3-small"
-    )
-    _provider: ClassVar[str] = "openai"
-
-    def embed(self, inputs: list[str]) -> OpenAIEmbeddingResponse:
-        """Call the embedder with multiple inputs"""
-        if self.embed_batch_size is None:
-            return self._embed(inputs)
-
-        input_batches = [
-            inputs[i : i + self.embed_batch_size]
-            for i in range(0, len(inputs), self.embed_batch_size)
-        ]
-
-        embedding_responses: list[OpenAIEmbeddingResponse] = list(
-            ThreadPoolExecutor(self.max_workers).map(
-                lambda inputs: self._embed(inputs),
-                input_batches,
-            )
-        )
-        return self._merge_batch_embeddings(embedding_responses)
-
-    async def embed_async(self, inputs: list[str]) -> OpenAIEmbeddingResponse:
-        """Asynchronously call the embedder with multiple inputs"""
-        if self.embed_batch_size is None:
-            return await self._embed_async(inputs)
-
-        input_batches = [
-            inputs[i : i + self.embed_batch_size]
-            for i in range(0, len(inputs), self.embed_batch_size)
-        ]
-        embedding_responses: list[OpenAIEmbeddingResponse] = await asyncio.gather(
-            *[self._embed_async(inputs) for inputs in input_batches]
-        )
-        return self._merge_batch_embeddings(embedding_responses)
-
-    def __call__(self, input: list[str]) -> list[list[float]]:
-        """Call the embedder with a input
-
-        Chroma expects parameter to be `input`.
-        """
-        embedding_response = self.embed(input)
-
-        return embedding_response.embeddings
-
-    ############################## PRIVATE METHODS ###################################
-
-    def _embed(self, inputs: list[str]) -> OpenAIEmbeddingResponse:
-        """Call the embedder with a single input"""
-        client = OpenAI(api_key=self.api_key, base_url=self.base_url)
-        kwargs = self.embedding_params.kwargs()
-        if self.embedding_params.model != "text-embedding-ada-002":
-            kwargs["dimensions"] = self.dimensions
-        start_time = datetime.datetime.now().timestamp() * 1000
-        embeddings = client.embeddings.create(input=inputs, **kwargs)
-        return OpenAIEmbeddingResponse(
-            response=embeddings,
-            start_time=start_time,
-            end_time=datetime.datetime.now().timestamp() * 1000,
-        )
-
-    async def _embed_async(self, inputs: list[str]) -> OpenAIEmbeddingResponse:
-        """Asynchronously call the embedder with a single input"""
-        client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
-        kwargs = self.embedding_params.kwargs()
-        if self.embedding_params.model != "text-embedding-ada-002":
-            kwargs["dimensions"] = self.dimensions
-        start_time = datetime.datetime.now().timestamp() * 1000
-        embeddings = await client.embeddings.create(input=inputs, **kwargs)
-        return OpenAIEmbeddingResponse(
-            response=embeddings,
-            start_time=start_time,
-            end_time=datetime.datetime.now().timestamp() * 1000,
-        )
-
-    def _merge_batch_embeddings(
-        self, openai_embeddings: list[OpenAIEmbeddingResponse]
-    ) -> OpenAIEmbeddingResponse:
-        """Merge a batch of embeddings into a single embedding"""
-        embeddings: list[Embedding] = []
-        usage = Usage(
-            prompt_tokens=0,
-            total_tokens=0,
-        )
-        start_time = float("inf")
-        end_time: float = 0.0
-        i: int = 0
-        for openai_embedding in openai_embeddings:
-            for embedding in openai_embedding.response.data:
-                embedding.index = i
-                embeddings.append(embedding)
-                i += 1
-            usage.prompt_tokens += openai_embedding.response.usage.prompt_tokens
-            usage.total_tokens += openai_embedding.response.usage.total_tokens
-            start_time = min(start_time, openai_embedding.start_time)
-            end_time = max(end_time, openai_embedding.end_time)
-        create_embedding_response = CreateEmbeddingResponse(
-            data=embeddings,
-            model=openai_embeddings[0].response.model,
-            object=openai_embeddings[0].response.object,
-            usage=usage,
-        )
-        return OpenAIEmbeddingResponse(
-            response=create_embedding_response,
-            start_time=start_time,
-            end_time=end_time,
-        )

mirascope/beta/rag/openai/embedding_params.py

@@ -1,18 +0,0 @@
-from typing import Literal
-
-from httpx import Timeout
-from openai._types import Body, Headers, Query
-
-from ..base.embedding_params import BaseEmbeddingParams
-
-
-class OpenAIEmbeddingParams(BaseEmbeddingParams):
-    model: str = "text-embedding-3-small"
-    encoding_format: Literal["float", "base64"] | None = None
-    user: str | None = None
-    # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-    # The extra values given here take precedence over values defined on the client or passed to this method.
-    extra_headers: Headers | None = None
-    extra_query: Query | None = None
-    extra_body: Body | None = None
-    timeout: float | Timeout | None = None

mirascope/beta/rag/openai/embedding_response.py

@@ -1,14 +0,0 @@
-from openai.types import Embedding
-from openai.types.create_embedding_response import CreateEmbeddingResponse
-
-from ..base.embedding_response import BaseEmbeddingResponse
-
-
-class OpenAIEmbeddingResponse(BaseEmbeddingResponse[CreateEmbeddingResponse]):
-    """A convenience wrapper around the OpenAI `CreateEmbeddingResponse` response."""
-
-    @property
-    def embeddings(self) -> list[list[float]]:
-        """Returns the raw embeddings."""
-        embeddings_model: list[Embedding] = list(self.response.data)
-        return [embedding.embedding for embedding in embeddings_model]

mirascope/beta/rag/pinecone/__init__.py

@@ -1,19 +0,0 @@
-"""A module for interacting with Pinecone vectorstores."""
-
-from .types import (
-    PineconeParams,
-    PineconePodParams,
-    PineconeQueryResult,
-    PineconeServerlessParams,
-    PineconeSettings,
-)
-from .vectorstores import PineconeVectorStore
-
-__all__ = [
-    "PineconeParams",
-    "PineconePodParams",
-    "PineconeQueryResult",
-    "PineconeServerlessParams",
-    "PineconeSettings",
-    "PineconeVectorStore",
-]

mirascope/beta/rag/pinecone/types.py

@@ -1,143 +0,0 @@
-"""Types for interacting with Pinecone using Mirascope."""
-
-from typing import Any, Literal
-
-from pinecone.config import Config
-from pinecone.core.client.api.manage_indexes_api import ManageIndexesApi
-from pydantic import BaseModel, ConfigDict
-
-from ..vectorstore_params import BaseVectorStoreParams
-
-
-class ServerlessSpec(BaseModel):
-    """The parameters for Pinecone ServerlessSpec"""
-
-    cloud: str
-    region: str
-
-    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 {"serverless": kwargs}
-
-
-class PodSpec(BaseModel):
-    """The parameters for Pinecone PodSpec"""
-
-    environment: str
-    replicas: int | None = None
-    shards: int | None = None
-    pods: int | None = None
-    pod_type: str | None = "p1.x1"
-    metadata_config: dict | None = {}
-    source_collection: str | None = None
-
-    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 {"pod": kwargs}
-
-
-class PineconeParams(BaseModel):
-    """The parameters for Pinecone create_index"""
-
-    metric: Literal["cosine", "dotproduct", "euclidean"] | None = "cosine"
-    timeout: int | None = None
-
-    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
-
-
-class PineconeServerlessParams(PineconeParams, ServerlessSpec, BaseVectorStoreParams):
-    """The parameters for Pinecone create_index with serverless spec and weave"""
-
-    def kwargs(self) -> dict[str, Any]:
-        """Returns all parameters for the index as a keyword arguments dictionary."""
-        serverless_kwargs = ServerlessSpec(**self.model_dump()).kwargs()
-        pinecone_kwargs = PineconeParams(**self.model_dump()).kwargs()
-        return {**pinecone_kwargs, "spec": {**serverless_kwargs}}
-
-
-class PineconePodParams(PineconeParams, PodSpec, BaseVectorStoreParams):
-    """The parameters for Pinecone create_index with pod spec and weave"""
-
-    def kwargs(self) -> dict[str, Any]:
-        """Returns all parameters for the index as a keyword arguments dictionary."""
-        pod_kwargs = PodSpec(**self.model_dump()).kwargs()
-        pinecone_kwargs = PineconeParams(**self.model_dump()).kwargs()
-        # print(pinecone_kwargs, serverless_kwargs)
-        return {**pinecone_kwargs, "spec": {**pod_kwargs}}
-
-
-class PineconeSettings(BaseModel):
-    """Settings for Pinecone instance"""
-
-    api_key: str | None = None
-    host: str | None = None
-    proxy_url: str | None = None
-    proxy_headers: dict[str, str] | None = None
-    ssl_ca_certs: str | None = None
-    ssl_verify: bool | None = None
-    config: Config | None = None
-    additional_headers: dict[str, str] | None = {}
-    pool_threads: int | None = 1
-    index_api: ManageIndexesApi | None = None
-
-    model_config = ConfigDict(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
-
-
-class PineconeQueryResult(BaseModel):
-    """The result of a Pinecone index query
-
-    Example:
-
-    ```python
-    from mirascope.pinecone import (
-        PineconeServerlessParams,
-        PineconeSettings,
-        PineconeVectorStore,
-    )
-    from mirascope.openai import OpenAIEmbedder
-    from mirascope.rag import TextChunker
-
-
-    class MyStore(ChromaVectorStore):
-        embedder = OpenAIEmbedder(dimensions=1536)
-        chunker = TextChunker(chunk_size=1000, chunk_overlap=200)
-        index_name = "my-store-0001"
-        api_key = settings.pinecone_api_key
-        client_settings = PineconeSettings()
-        vectorstore_params = PineconeServerlessParams(
-            cloud="aws",
-            region="us-west-2",
-        )
-
-    my_store = MyStore()
-    with open(f"{PATH_TO_FILE}") as file:
-        data = file.read()
-        my_store.add(data)
-    query_results = my_store.retrieve("my question")
-    #> QueryResult(ids=['0'], documents=['my answer'],
-    # scores=[0.9999999999999999], embeddings=[[0.0, 0.0, 0.0, ...]])
-    ```
-    """
-
-    ids: list[str]
-    documents: list[str] | None = None
-    scores: list[float] | None = None
-    embeddings: list[list[float]] | None = None

mirascope/beta/rag/pinecone/vectorstores.py

@@ -1,148 +0,0 @@
-"""A module for calling Chroma's Client and Collection."""
-
-from collections.abc import Callable
-from functools import cached_property
-from typing import Any, ClassVar
-
-from pinecone import Index, Pinecone, QueryResponse
-
-from ..base.document import Document
-from ..base.embedding_response import BaseEmbeddingResponse
-from ..base.vectorstores import BaseVectorStore
-from .types import (
-    PineconePodParams,
-    PineconeQueryResult,
-    PineconeServerlessParams,
-    PineconeSettings,
-)
-
-
-class PineconeVectorStore(BaseVectorStore):
-    """A vectorstore for Pinecone.
-
-    Example:
-
-    ```python
-    from mirascope.beta.rag.pinecone import (
-        PineconeServerlessParams,
-        PineconeSettings,
-        PineconeVectorStore,
-    )
-    from mirascope.beta.rag.openai import OpenAIEmbedder
-    from mirascope.beta.rag import TextChunker
-
-
-    class MyStore(PineconeVectorStore):
-        embedder = OpenAIEmbedder(dimensions=1536)
-        chunker = TextChunker(chunk_size=1000, chunk_overlap=200)
-        index_name = "my-store-0001"
-        api_key = settings.pinecone_api_key
-        client_settings = PineconeSettings()
-        vectorstore_params = PineconeServerlessParams(
-            cloud="aws",
-            region="us-west-2",
-        )
-
-    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)
-    ```
-    """
-
-    handle_add_text: Callable[[list[Document]], None] | None = None
-    handle_retrieve_text: Callable[[list[float]], list[str]] | None = None
-
-    vectorstore_params: ClassVar[PineconePodParams | PineconeServerlessParams] = (
-        PineconeServerlessParams(cloud="aws", region="us-east-1")
-    )
-    client_settings: ClassVar[PineconeSettings] = PineconeSettings()
-    _provider: ClassVar[str] = "pinecone"
-
-    def retrieve(self, text: str, **kwargs: Any) -> PineconeQueryResult:  # noqa: ANN401
-        """Queries the vectorstore for closest match"""
-        embed = self.embedder.embed
-        text_embedding: BaseEmbeddingResponse = embed([text])
-        if "top_k" not in kwargs:
-            kwargs["top_k"] = 8
-        if text_embedding.embeddings is None:
-            raise ValueError("Embedding is None")
-        query_result: QueryResponse = self._index.query(
-            vector=text_embedding.embeddings[0],
-            **{"include_metadata": True, "include_values": True, **kwargs},
-        )
-        ids: list[str] = []
-        scores: list[float] = []
-        documents: list[str] = []
-        embeddings: list[list[float]] = []
-        for match in query_result.matches:
-            ids.append(match.id)
-            scores.append(match.score)
-            documents.append(
-                self.handle_retrieve_text([match.values])[0]
-                if self.handle_retrieve_text
-                else match.metadata["text"]
-            )
-            embeddings.append(match.values)
-
-        return PineconeQueryResult(
-            ids=ids,
-            scores=scores,
-            documents=documents,
-            embeddings=embeddings,
-        )
-
-    def add(
-        self,
-        text: str | list[Document],
-        **kwargs: Any,  # noqa: ANN401
-    ) -> None:
-        """Takes unstructured data and upserts into vectorstore"""
-        documents: list[Document]
-        if isinstance(text, str):
-            chunk = self.chunker.chunk
-            documents = chunk(text)
-        else:
-            documents = text
-        inputs = [document.text for document in documents]
-        embed = self.embedder.embed
-        embedding_repsonse: BaseEmbeddingResponse = embed(inputs)
-        if self.handle_add_text:
-            self.handle_add_text(documents)
-        if embedding_repsonse.embeddings is None:
-            raise ValueError("Embedding is None")
-        vectors = []
-        for i, embedding in enumerate(embedding_repsonse.embeddings):
-            if documents[i] is not None:
-                metadata = documents[i].metadata or {}
-                metadata_text = (
-                    {"text": documents[i].text}
-                    if documents[i].text and not self.handle_add_text
-                    else {}
-                )
-                vectors.append(
-                    {
-                        "id": documents[i].id,
-                        "values": embedding,
-                        "metadata": {**metadata, **metadata_text},
-                    }
-                )
-        return self._index.upsert(vectors, **kwargs)
-
-    ############################# PRIVATE PROPERTIES #################################
-
-    @cached_property
-    def _client(self) -> Pinecone:
-        return Pinecone(api_key=self.api_key, **self.client_settings.kwargs())
-
-    @cached_property
-    def _index(self) -> Index:
-        if self.index_name not in self._client.list_indexes().names():
-            self._client.create_index(
-                name=self.index_name,
-                dimension=self.embedder.dimensions,
-                **self.vectorstore_params.kwargs(),
-            )
-        return self._client.Index(self.index_name)

mirascope/beta/rag/weaviate/__init__.py

@@ -1,6 +0,0 @@
-"""A module for interacting with Weaviate vectorstores."""
-
-from .types import WeaviateParams, WeaviateSettings
-from .vectorstores import WeaviateVectorStore
-
-__all__ = ["WeaviateParams", "WeaviateSettings", "WeaviateVectorStore"]

mirascope/beta/rag/weaviate/types.py

@@ -1,92 +0,0 @@
-"""Types for interacting with Weaviate using Mirascope."""
-
-from __future__ import annotations
-
-from typing import Any, Literal
-
-import weaviate.types as wt
-from pydantic import BaseModel, ConfigDict
-
-from ..base.document import Document
-from ..base.vectorstore_params import BaseVectorStoreParams
-
-
-class WeaviateSettings(BaseModel):
-    mode: Literal["local", "cloud", "custom", "embedded"] = "local"
-    headers: dict[str, str] | None = None
-    cluster_url: str | None = None
-    auth_credentials: Any | None = None
-    hostname: str | None = None
-    port: int | None = None
-    grpc_port: int | None = None
-    additional_config: Any | None = None
-    version: str | None = None
-    persistence_data_path: str | None = None
-    binary_path: str | None = None
-    environment_variables: dict[str, str] | None = None
-    http_host: str | None = None
-    http_port: int | None = None
-    http_secure: bool | None = None
-    grpc_host: str | None = None
-    grpc_secure: bool | None = None
-
-    skip_init_checks: bool | None = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def kwargs(self) -> dict[str, Any]:
-        kwargs = {}
-        exclude = {"mode"}
-        if self.auth_credentials:
-            kwargs["auth_credentials"] = self.auth_credentials
-            exclude.add("auth_credentials")
-        if self.additional_config:
-            kwargs["additional_config"] = self.additional_config
-            exclude.add("additional_config")
-        additional_kwargs = {
-            key: value
-            for key, value in self.model_dump(exclude=exclude).items()
-            if value is not None
-        }
-        kwargs.update(additional_kwargs)
-        return kwargs
-
-
-class WeaviateParams(BaseVectorStoreParams):
-    vectorizer_config: Any | None = None
-    generative_config: Any | None = None
-
-    def kwargs(self) -> dict[str, Any]:
-        kwargs = {}
-        exclude = set()
-        if self.vectorizer_config:
-            kwargs["vectorizer_config"] = self.vectorizer_config
-            exclude = {"vectorizer_config"}
-        additional_kwargs = {
-            key: value
-            for key, value in self.model_dump(exclude=exclude).items()
-            if value is not None
-        }
-        kwargs.update(additional_kwargs)
-        return kwargs
-
-
-class WeaviateQueryResult(BaseModel):
-    id: wt.UUID
-    documents: list[Document] | None
-    metadata: dict[str, Any]
-    collection: str | None = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def from_response(response_object) -> WeaviateQueryResult:
-        model_dict = {}
-        id = str(response_object.uuid)
-        text = response_object.properties["text"]
-        model_dict["id"] = id
-        doc = Document(id=id, text=text)
-        model_dict["documents"] = [doc]
-        model_dict["metadata"] = response_object.metadata.__dict__
-        model_dict["collection"] = response_object.collection
-
-        return WeaviateQueryResult.model_validate(model_dict)