nucliadb-utils 5.0.0.post777__py3-none-any.whl → 5.0.0.post796__py3-none-any.whl

nucliadb_utils/aiopynecone/client.py

@@ -17,11 +17,24 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
+import asyncio
+import json
 import logging
+import random
+from collections.abc import AsyncIterable, Iterable
+from itertools import islice
+from typing import Any, AsyncGenerator, Optional
 
 import httpx
 
 from nucliadb_telemetry.metrics import Observer
+from nucliadb_utils.aiopynecone.models import (
+    CreateIndexResponse,
+    ListResponse,
+    QueryResponse,
+    UpsertRequest,
+    Vector,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -30,54 +43,465 @@ pinecone_observer = Observer(
     labels={"type": ""},
 )
 
-BASE_URL = "https://api.pinecone.io/"
+DEFAULT_TIMEOUT = 30
+CONTROL_PLANE_BASE_URL = "https://api.pinecone.io/"
+INDEX_HOST_BASE_URL = "https://{index_host}/"
+BASE_API_HEADERS = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+}
+MEGA_BYTE = 1024 * 1024
+MAX_UPSERT_PAYLOAD_SIZE = 2 * MEGA_BYTE
+MAX_DELETE_BATCH_SIZE = 1000
+
+
+class PineconeAPIError(Exception):
+    def __init__(
+        self,
+        http_status_code: int,
+        code: Optional[str] = None,
+        message: Optional[str] = None,
+        details: Optional[Any] = None,
+    ):
+        self.http_status_code = http_status_code
+        self.code = code or ""
+        self.message = message or ""
+        self.details = details or {}
+        exc_message = '[{http_status_code}] message="{message}" code={code} details={details}'.format(
+            http_status_code=http_status_code,
+            message=message,
+            code=code,
+            details=details,
+        )
+        super().__init__(exc_message)
+
 
+class ControlPlane:
+    """
+    Client for interacting with the Pinecone control plane API.
+    https://docs.pinecone.io/reference/api/control-plane
+    """
 
-class PineconeClient:
     def __init__(self, api_key: str, http_session: httpx.AsyncClient):
         self.api_key = api_key
-        self.session = http_session
+        self.http_session = http_session
 
     @pinecone_observer.wrap({"type": "create_index"})
-    async def create_index(self, name: str, dimension: int) -> str:
+    async def create_index(self, name: str, dimension: int, metric: str = "dotproduct") -> str:
+        """
+        Create a new index in Pinecone. It can only create serverless indexes on the AWS us-east-1 region.
+        Params:
+        - `name`: The name of the index.
+        - `dimension`: The dimension of the vectors in the index.
+        - `metric`: The similarity metric to use. Default is "dotproduct".
+        Returns:
+        - The index host to be used for data plane operations.
+        """
         payload = {
             "name": name,
             "dimension": dimension,
-            "metric": "dotproduct",
+            "metric": metric,
             "spec": {"serverless": {"cloud": "aws", "region": "us-east-1"}},
         }
         headers = {"Api-Key": self.api_key}
-        response = await self.session.post("/indexes", json=payload, headers=headers)
-        response.raise_for_status()
-        response_json = response.json()
-        return response_json["host"]
+        http_response = await self.http_session.post("/indexes", json=payload, headers=headers)
+        raise_for_status(http_response)
+        response = CreateIndexResponse.model_validate(http_response.json())
+        return response.host
 
     @pinecone_observer.wrap({"type": "delete_index"})
     async def delete_index(self, name: str) -> None:
+        """
+        Delete an index in Pinecone.
+        Params:
+        - `name`: The name of the index to delete.
+        """
         headers = {"Api-Key": self.api_key}
-        response = await self.session.delete(f"/indexes/{name}", headers=headers)
-        if response.status_code == 404:
+        response = await self.http_session.delete(f"/indexes/{name}", headers=headers)
+        if response.status_code == 404:  # pragma: no cover
             logger.warning("Pinecone index not found.", extra={"index_name": name})
             return
-        response.raise_for_status()
+        raise_for_status(response)
+
+
+class DataPlane:
+    """
+    Client for interacting with the Pinecone data plane API, hosted by an index host.
+    https://docs.pinecone.io/reference/api/data-plane
+    """
+
+    def __init__(
+        self, api_key: str, index_host_session: httpx.AsyncClient, timeout: Optional[float] = None
+    ):
+        """
+        Params:
+        - `api_key`: The Pinecone API key.
+        - `index_host_session`: The http session for the index host.
+        - `timeout`: The default timeout for all requests. If not set, the default timeout from httpx.AsyncClient is used.
+        """
+        self.api_key = api_key
+        self.http_session = index_host_session
+        self.client_timeout = timeout
+        self._upsert_batch_size: Optional[int] = None
+
+    def _get_request_timeout(self, timeout: Optional[float] = None) -> Optional[float]:
+        return timeout or self.client_timeout
+
+    @pinecone_observer.wrap({"type": "upsert"})
+    async def upsert(self, vectors: list[Vector], timeout: Optional[float] = None) -> None:
+        """
+        Upsert vectors into the index.
+        Params:
+        - `vectors`: The vectors to upsert.
+        - `timeout`: to control the request timeout. If not set, the default timeout is used.
+        """
+        headers = {"Api-Key": self.api_key}
+        payload = UpsertRequest(vectors=vectors)
+        post_kwargs: dict[str, Any] = {
+            "headers": headers,
+            "json": payload.model_dump(),
+        }
+        request_timeout = self._get_request_timeout(timeout)
+        if request_timeout is not None:
+            post_kwargs["timeout"] = timeout
+        response = await self.http_session.post("/vectors/upsert", **post_kwargs)
+        raise_for_status(response)
+
+    def _estimate_upsert_batch_size(self, vectors: list[Vector]) -> int:
+        """
+        Estimate a batch size so that the upsert payload does not exceed the hard limit.
+        https://docs.pinecone.io/reference/quotas-and-limits#hard-limits
+        """
+        if self._upsert_batch_size is not None:
+            # Return the cached value.
+            return self._upsert_batch_size
+        # Take the dimension of the first vector as the vector dimension.
+        # Assumes all vectors have the same dimension.
+        vector_dimension = len(vectors[0].values)
+        # Estimate the metadata size by taking the average of 20 random vectors.
+        metadata_sizes = []
+        for _ in range(20):
+            metadata_sizes.append(len(json.dumps(random.choice(vectors).metadata)))
+        average_metadata_size = sum(metadata_sizes) / len(metadata_sizes)
+        # Estimate the size of the vector payload. 4 bytes per float.
+        vector_size = 4 * vector_dimension + average_metadata_size
+        # Cache the value.
+        self._upsert_batch_size = max(int(MAX_UPSERT_PAYLOAD_SIZE // vector_size), 1)
+        return self._upsert_batch_size
+
+    @pinecone_observer.wrap({"type": "upsert_in_batches"})
+    async def upsert_in_batches(
+        self,
+        vectors: list[Vector],
+        batch_size: Optional[int] = None,
+        max_parallel_batches: int = 1,
+        batch_timeout: Optional[float] = None,
+    ) -> None:
+        """
+        Upsert vectors in batches.
+        Params:
+        - `vectors`: The vectors to upsert.
+        - `batch_size`: to control the number of vectors in each batch.
+        - `max_parallel_batches`: to control the number of batches sent concurrently.
+        - `batch_timeout`: to control the request timeout for each batch.
+        """
+        if batch_size is None:
+            batch_size = self._estimate_upsert_batch_size(vectors)
+
+        semaphore = asyncio.Semaphore(max_parallel_batches)
+
+        async def _upsert_batch(batch):
+            async with semaphore:
+                await self.upsert(vectors=batch, timeout=batch_timeout)
+
+        tasks = []
+        for batch in batchify(vectors, batch_size):
+            tasks.append(asyncio.create_task(_upsert_batch(batch)))
+
+        await asyncio.gather(*tasks)
+
+    @pinecone_observer.wrap({"type": "delete"})
+    async def delete(self, ids: list[str], timeout: Optional[float] = None) -> None:
+        """
+        Delete vectors by their ids.
+        Maximum number of ids in a single request is 1000.
+        Params:
+        - `ids`: The ids of the vectors to delete.
+        - `timeout`: to control the request timeout. If not set, the default timeout is used.
+        """
+        if len(ids) > MAX_DELETE_BATCH_SIZE:
+            raise ValueError(f"Maximum number of ids in a single request is {MAX_DELETE_BATCH_SIZE}.")
+
+        headers = {"Api-Key": self.api_key}
+        payload = {"ids": ids}
+        post_kwargs: dict[str, Any] = {
+            "headers": headers,
+            "json": payload,
+        }
+        request_timeout = self._get_request_timeout(timeout)
+        if request_timeout is not None:
+            post_kwargs["timeout"] = timeout
+        response = await self.http_session.post("/vectors/delete", **post_kwargs)
+        raise_for_status(response)
+
+    @pinecone_observer.wrap({"type": "list_page"})
+    async def list_page(
+        self,
+        id_prefix: Optional[str] = None,
+        limit: int = 100,
+        pagination_token: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> ListResponse:
+        """
+        List vectors in a paginated manner.
+        Params:
+        - `id_prefix`: to filter vectors by their id prefix.
+        - `limit`: to control the number of vectors fetched in each page.
+        - `pagination_token`: to fetch the next page. The token is provided in the response
+           if there are more pages to fetch.
+        - `timeout`: to control the request timeout. If not set, the default timeout is used.
+        """
+        headers = {"Api-Key": self.api_key}
+        params = {"limit": str(limit)}
+        if id_prefix is not None:
+            params["prefix"] = id_prefix
+        if pagination_token is not None:
+            params["paginationToken"] = pagination_token
+
+        post_kwargs: dict[str, Any] = {
+            "headers": headers,
+            "params": params,
+        }
+        request_timeout = self._get_request_timeout(timeout)
+        if request_timeout is not None:
+            post_kwargs["timeout"] = timeout
+        response = await self.http_session.get(
+            "/vectors/list",
+            **post_kwargs,
+        )
+        raise_for_status(response)
+        return ListResponse.model_validate(response.json())
+
+    async def list_all(
+        self, id_prefix: Optional[str] = None, page_size: int = 100, page_timeout: Optional[float] = None
+    ) -> AsyncGenerator[str, None]:
+        """
+        Iterate over all vector ids from the index in a paginated manner.
+        Params:
+        - `id_prefix`: to filter vectors by their id prefix.
+        - `page_size`: to control the number of vectors fetched in each page.
+        - `page_timeout`: to control the request timeout for each page. If not set, the default timeout is used.
+        """
+        pagination_token = None
+        while True:
+            response = await self.list_page(
+                id_prefix=id_prefix,
+                limit=page_size,
+                pagination_token=pagination_token,
+                timeout=page_timeout,
+            )
+            for vector_id in response.vectors:
+                yield vector_id.id
+            if response.pagination is None:
+                break
+            pagination_token = response.pagination.next
+
+    @pinecone_observer.wrap({"type": "delete_all"})
+    async def delete_all(self, timeout: Optional[float] = None):
+        """
+        Delete all vectors in the index.
+        Params:
+        - `timeout`: to control the request timeout. If not set, the default timeout is used.
+        """
+        headers = {"Api-Key": self.api_key}
+        payload = {"deleteAll": True, "ids": [], "namespace": ""}
+        post_kwargs: dict[str, Any] = {
+            "headers": headers,
+            "json": payload,
+        }
+        request_timeout = self._get_request_timeout(timeout)
+        if request_timeout is not None:
+            post_kwargs["timeout"] = timeout
+        response = await self.http_session.post("/vectors/delete", **post_kwargs)
+        try:
+            raise_for_status(response)
+        except PineconeAPIError as err:
+            if err.http_status_code == 404 and err.code == 5:  # pragma: no cover
+                # Namespace not found. No vectors to delete.
+                return
+            raise
+
+    @pinecone_observer.wrap({"type": "delete_by_id_prefix"})
+    async def delete_by_id_prefix(
+        self,
+        id_prefix: str,
+        batch_size: int = MAX_DELETE_BATCH_SIZE,
+        max_parallel_batches: int = 1,
+        batch_timeout: Optional[float] = None,
+    ) -> None:
+        """
+        Delete vectors by their id prefix. It lists all vectors with the given prefix and deletes them in batches.
+        Params:
+        - `id_prefix`: to filter vectors by their id prefix.
+        - `batch_size`: to control the number of vectors deleted in each batch. Maximum is 1000.
+        - `max_parallel_batches`: to control the number of batches sent concurrently.
+        - `batch_timeout`: to control the request timeout for each batch.
+        """
+        if batch_size > MAX_DELETE_BATCH_SIZE:
+            logger.warning(f"Batch size {batch_size} is too large. Limiting to {MAX_DELETE_BATCH_SIZE}.")
+            batch_size = MAX_DELETE_BATCH_SIZE
+
+        semaphore = asyncio.Semaphore(max_parallel_batches)
+
+        async def _delete_batch(batch):
+            async with semaphore:
+                await self.delete(ids=batch, timeout=batch_timeout)
+
+        tasks = []
+        async_iterable = self.list_all(
+            id_prefix=id_prefix, page_size=batch_size, page_timeout=batch_timeout
+        )
+        async for batch in async_batchify(async_iterable, batch_size):
+            tasks.append(asyncio.create_task(_delete_batch(batch)))
+
+        await asyncio.gather(*tasks)
+
+    @pinecone_observer.wrap({"type": "query"})
+    async def query(
+        self,
+        vector: list[float],
+        top_k: int = 20,
+        include_values: bool = False,
+        include_metadata: bool = False,
+        filter: Optional[dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+    ) -> QueryResponse:
+        """
+        Query the index for similar vectors to the given vector.
+        Params:
+        - `vector`: The query vector.
+        - `top_k`: to control the number of similar vectors to return.
+        - `include_values`: to include the vector values in the response.
+        - `include_metadata`: to include the vector metadata in the response.
+        - `filter`: to filter the vectors by their metadata. See:
+           https://docs.pinecone.io/guides/data/filter-with-metadata#metadata-query-language
+        - `timeout`: to control the request timeout. If not set, the default timeout is used.
+        """
+        headers = {"Api-Key": self.api_key}
+        payload = {
+            "vector": vector,
+            "topK": top_k,
+            "includeValues": include_values,
+            "includeMetadata": include_metadata,
+        }
+        if filter:
+            payload["filter"] = filter
+        post_kwargs: dict[str, Any] = {
+            "headers": headers,
+            "json": payload,
+        }
+        request_timeout = self._get_request_timeout(timeout)
+        if request_timeout is not None:
+            post_kwargs["timeout"] = timeout
+        response = await self.http_session.post("/query", **post_kwargs)
+        raise_for_status(response)
+        return QueryResponse.model_validate(response.json())
 
 
 class PineconeSession:
     """
-    Wrapper that manages the singletone session around all Pinecone http api interactions.
+    Wrapper class that manages the sessions around all Pinecone http api interactions.
+    Holds a single control plane session and multiple data plane sessions, one for each index host.
     """
 
     def __init__(self):
-        self.headers = {
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-        }
-        self.http_session = httpx.AsyncClient(base_url=BASE_URL, headers=self.headers)
+        self.control_plane_session = httpx.AsyncClient(
+            base_url=CONTROL_PLANE_BASE_URL, headers=BASE_API_HEADERS, timeout=DEFAULT_TIMEOUT
+        )
+        self.index_host_sessions = {}
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.finalize()
 
     async def finalize(self):
-        if self.http_session.is_closed:
-            return
-        await self.http_session.aclose()
+        if not self.control_plane_session.is_closed:
+            await self.control_plane_session.aclose()
+        for session in self.index_host_sessions.values():
+            if not session.is_closed:
+                await session.aclose()
+        self.index_host_sessions.clear()
+
+    def control_plane(self, api_key: str) -> ControlPlane:
+        return ControlPlane(api_key=api_key, http_session=self.control_plane_session)
+
+    def _get_index_host_session(self, index_host: str) -> httpx.AsyncClient:
+        """
+        Get a session for the given index host.
+        Cache http sessions so that they are reused for the same index host.
+        """
+        session = self.index_host_sessions.get(index_host, None)
+        if session is not None:
+            return session
+
+        session = httpx.AsyncClient(
+            base_url=INDEX_HOST_BASE_URL.format(index_host=index_host),
+            headers=BASE_API_HEADERS,
+            timeout=DEFAULT_TIMEOUT,
+        )
+        self.index_host_sessions[index_host] = session
+        return session
+
+    def data_plane(self, api_key: str, index_host: str, timeout: Optional[float] = None) -> DataPlane:
+        index_host_session = self._get_index_host_session(index_host)
+        return DataPlane(api_key=api_key, index_host_session=index_host_session, timeout=timeout)
+
+
+def raise_for_status(response: httpx.Response):
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError:
+        code = None
+        message = None
+        details = None
+        try:
+            resp_json = response.json()
+            code = resp_json.get("code")
+            message = resp_json.get("message")
+            details = resp_json.get("details")
+        except Exception:
+            message = response.text
+        raise PineconeAPIError(
+            http_status_code=response.status_code,
+            code=code,
+            message=message,
+            details=details,
+        )
+
+
+def batchify(iterable: Iterable, batch_size: int):
+    """
+    Split an iterable into batches of batch_size
+    """
+    iterator = iter(iterable)
+    while True:
+        batch = list(islice(iterator, batch_size))
+        if not batch:
+            break
+        yield batch
+
 
-    def get_client(self, api_key: str) -> PineconeClient:
-        return PineconeClient(api_key=api_key, http_session=self.http_session)
+async def async_batchify(async_iterable: AsyncIterable, batch_size: int):
+    """
+    Split an async iterable into batches of batch_size
+    """
+    batch = []
+    async for item in async_iterable:
+        batch.append(item)
+        if len(batch) == batch_size:
+            yield batch
+            batch = []
+    if batch:
+        yield batch

nucliadb_utils/aiopynecone/models.py

@@ -0,0 +1,79 @@
+# Copyright (C) 2021 Bosutech XXI S.L.
+#
+# nucliadb is offered under the AGPL v3.0 and as commercial software.
+# For commercial licensing, contact us at info@nuclia.com.
+#
+# AGPL:
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+import json
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+KILO_BYTE = 1024
+MAX_METADATA_SIZE = 40 * KILO_BYTE
+
+
+# Requests
+
+
+class Vector(BaseModel):
+    id: str = Field(max_length=512)
+    values: list[float]
+    metadata: dict[str, Any] = {}
+
+    @field_validator("metadata", mode="after")
+    @classmethod
+    def validate_metadata_size(cls, value):
+        json_value = json.dumps(value)
+        if len(json_value) > MAX_METADATA_SIZE:
+            raise ValueError("metadata size is too large")
+
+
+class UpsertRequest(BaseModel):
+    vectors: list[Vector]
+
+
+# Responses
+
+
+class CreateIndexResponse(BaseModel):
+    host: str
+
+
+class VectorId(BaseModel):
+    id: str
+
+
+class Pagination(BaseModel):
+    next: str
+
+
+class ListResponse(BaseModel):
+    vectors: list[VectorId]
+    pagination: Optional[Pagination] = None
+
+
+class VectorMatch(BaseModel):
+    id: str
+    score: float
+    # Only populated if `includeValues` is set to `True
+    values: Optional[list[float]] = None
+    # Only populated if `includeMetadata` is set to `True
+    metadata: Optional[dict[str, Any]] = None
+
+
+class QueryResponse(BaseModel):
+    matches: list[VectorMatch]

nucliadb_utils/utilities.py

@@ -429,7 +429,7 @@ def get_endecryptor() -> EndecryptorUtility:
     return util
 
 
-def get_pinecone_session() -> PineconeSession:
+def get_pinecone() -> PineconeSession:
     util = get_utility(Utility.PINECONE_SESSION)
     if util is not None:
         return util

{nucliadb_utils-5.0.0.post777.dist-info → nucliadb_utils-5.0.0.post796.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nucliadb_utils
-Version: 5.0.0.post777
+Version: 5.0.0.post796
 Home-page: https://nuclia.com
 License: BSD
 Classifier: Development Status :: 4 - Beta
@@ -23,8 +23,8 @@ Requires-Dist: PyNaCl
 Requires-Dist: pyjwt >=2.4.0
 Requires-Dist: memorylru >=1.1.2
 Requires-Dist: mrflagly
-Requires-Dist: nucliadb-protos >=5.0.0.post777
-Requires-Dist: nucliadb-telemetry >=5.0.0.post777
+Requires-Dist: nucliadb-protos >=5.0.0.post796
+Requires-Dist: nucliadb-telemetry >=5.0.0.post796
 Provides-Extra: cache
 Requires-Dist: redis >=4.3.4 ; extra == 'cache'
 Requires-Dist: orjson >=3.6.7 ; extra == 'cache'
@@ -54,6 +54,6 @@ Requires-Dist: azure-identity >=1.16.1 ; extra == 'storages'
 # Install and run tests
 
 ```bash
-make install-dev
+pdm sync -d
 make test
 ```

{nucliadb_utils-5.0.0.post777.dist-info → nucliadb_utils-5.0.0.post796.dist-info}/RECORD

@@ -16,9 +16,10 @@ nucliadb_utils/settings.py,sha256=AaOtQZVRqRcMnUyN1l1MpR10lANaDT2uPrbhmTyn6uk,76
 nucliadb_utils/signals.py,sha256=JRNv2y9zLtBjOANBf7krGfDGfOc9qcoXZ6N1nKWS2FE,2674
 nucliadb_utils/store.py,sha256=kQ35HemE0v4_Qg6xVqNIJi8vSFAYQtwI3rDtMsNy62Y,890
 nucliadb_utils/transaction.py,sha256=mwcI3aIHAvU5KOGqd_Uz_d1XQzXhk_-NWY8NqU1lfb0,7307
-nucliadb_utils/utilities.py,sha256=Hgca8E_VvjsszzHT4ABcqfzvhuRbtQIK2GCkm50UHI0,15295
+nucliadb_utils/utilities.py,sha256=oz3tEODG2g3todnyvA-nW1Ou6xXDveL_tMKTDGdWXM4,15287
 nucliadb_utils/aiopynecone/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
-nucliadb_utils/aiopynecone/client.py,sha256=uY6X-CnOAx6HlZHLlA8xOTDlYWwHegib9c9YwUTp2DA,2855
+nucliadb_utils/aiopynecone/client.py,sha256=kvGLCzSbDaMIWx0LK9WBAL7QsyuPmUjC7cPv5djMdFw,19028
+nucliadb_utils/aiopynecone/models.py,sha256=DVlCVrinHAaDxuii3fzdciFn4dqS5HTTyBavnoDlR2U,2024
 nucliadb_utils/audit/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb_utils/audit/audit.py,sha256=dn5ZnCVQUlCcvdjzaORghbrjk9QgVGrtkfIftq30Bp8,2819
 nucliadb_utils/audit/basic.py,sha256=NViey6mKbCXqRTLDBX2xNTcCg9I-2e4oB2xkekuhDvM,3392
@@ -62,8 +63,8 @@ nucliadb_utils/tests/indexing.py,sha256=YW2QhkhO9Q_8A4kKWJaWSvXvyQ_AiAwY1VylcfVQ
 nucliadb_utils/tests/local.py,sha256=c3gZJJWmvOftruJkIQIwB3q_hh3uxEhqGIAVWim1Bbk,1343
 nucliadb_utils/tests/nats.py,sha256=Tosonm9A9cusImyji80G4pgdXEHNVPaCLT5TbFK_ra0,7543
 nucliadb_utils/tests/s3.py,sha256=YB8QqDaBXxyhHonEHmeBbRRDmvB7sTOaKBSi8KBGokg,2330
-nucliadb_utils-5.0.0.post777.dist-info/METADATA,sha256=tBDJn27_vccmXADLM2EhzY_ffc-97admPB2bMWBN5IA,2078
-nucliadb_utils-5.0.0.post777.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-nucliadb_utils-5.0.0.post777.dist-info/top_level.txt,sha256=fE3vJtALTfgh7bcAWcNhcfXkNPp_eVVpbKK-2IYua3E,15
-nucliadb_utils-5.0.0.post777.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-nucliadb_utils-5.0.0.post777.dist-info/RECORD,,
+nucliadb_utils-5.0.0.post796.dist-info/METADATA,sha256=mwdR7jpGf8oA1T8pa62MXf_BajMORpePKeK7KpiujIM,2073
+nucliadb_utils-5.0.0.post796.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+nucliadb_utils-5.0.0.post796.dist-info/top_level.txt,sha256=fE3vJtALTfgh7bcAWcNhcfXkNPp_eVVpbKK-2IYua3E,15
+nucliadb_utils-5.0.0.post796.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+nucliadb_utils-5.0.0.post796.dist-info/RECORD,,