nucliadb-utils 5.0.0.post902__py3-none-any.whl → 5.0.0.post906__py3-none-any.whl

nucliadb_utils/aiopynecone/client.py

@@ -60,6 +60,10 @@ INDEX_HOST_BASE_URL = "https://{index_host}/"
 BASE_API_HEADERS = {
     "Content-Type": "application/json",
     "Accept": "application/json",
+    # This is needed so that it is easier for Pinecone to track which api requests
+    # are coming from the Nuclia integration:
+    # https://docs.pinecone.io/integrations/build-integration/attribute-usage-to-your-integration
+    "User-Agent": "source_tag=nuclia",
 }
 MEGA_BYTE = 1024 * 1024
 MAX_UPSERT_PAYLOAD_SIZE = 2 * MEGA_BYTE
@@ -73,13 +77,6 @@ RETRIABLE_EXCEPTIONS = (
     httpx.NetworkError,
 )
 
-backoff_handler = backoff.on_exception(
-    backoff.expo,
-    RETRIABLE_EXCEPTIONS,
-    jitter=backoff.random_jitter,
-    max_tries=4,
-)
-
 
 class ControlPlane:
     """
@@ -154,7 +151,12 @@ class DataPlane:
     def _get_request_timeout(self, timeout: Optional[float] = None) -> Optional[float]:
         return timeout or self.client_timeout
 
-    @backoff_handler
+    @backoff.on_exception(
+        backoff.expo,
+        RETRIABLE_EXCEPTIONS,
+        jitter=backoff.random_jitter,
+        max_tries=4,
+    )
     @pinecone_observer.wrap({"type": "upsert"})
     async def upsert(self, vectors: list[Vector], timeout: Optional[float] = None) -> None:
         """
@@ -231,7 +233,12 @@ class DataPlane:
 
         await asyncio.gather(*tasks)
 
-    @backoff_handler
+    @backoff.on_exception(
+        backoff.expo,
+        RETRIABLE_EXCEPTIONS,
+        jitter=backoff.random_jitter,
+        max_tries=4,
+    )
     @pinecone_observer.wrap({"type": "delete"})
     async def delete(self, ids: list[str], timeout: Optional[float] = None) -> None:
         """
@@ -256,7 +263,12 @@ class DataPlane:
         response = await self.http_session.post("/vectors/delete", **post_kwargs)
         raise_for_status("delete", response)
 
-    @backoff_handler
+    @backoff.on_exception(
+        backoff.expo,
+        RETRIABLE_EXCEPTIONS,
+        jitter=backoff.random_jitter,
+        max_tries=4,
+    )
     @pinecone_observer.wrap({"type": "list_page"})
     async def list_page(
         self,
@@ -324,7 +336,12 @@ class DataPlane:
                 break
             pagination_token = response.pagination.next
 
-    @backoff_handler
+    @backoff.on_exception(
+        backoff.expo,
+        RETRIABLE_EXCEPTIONS,
+        jitter=backoff.random_jitter,
+        max_tries=4,
+    )
     @pinecone_observer.wrap({"type": "delete_all"})
     async def delete_all(self, timeout: Optional[float] = None):
         """
@@ -383,7 +400,12 @@ class DataPlane:
 
         await asyncio.gather(*tasks)
 
-    @backoff_handler
+    @backoff.on_exception(
+        backoff.expo,
+        RETRIABLE_EXCEPTIONS,
+        jitter=backoff.random_jitter,
+        max_tries=4,
+    )
     @pinecone_observer.wrap({"type": "query"})
     async def query(
         self,

nucliadb_utils/indexing.py

@@ -17,84 +17,47 @@
 # 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/>.
 #
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-import nats
-from nats.aio.client import Client
-from nats.js.client import JetStreamContext
+from typing import List, Optional, Tuple
 
 from nucliadb_protos.nodewriter_pb2 import IndexMessage
-from nucliadb_telemetry.jetstream import JetStreamContextTelemetry
 from nucliadb_utils import const, logger
-from nucliadb_utils.nats import get_traced_jetstream
+from nucliadb_utils.nats import NatsConnectionManager
 
 
 class IndexingUtility:
-    nc: Optional[Client] = None
-    js: Optional[Union[JetStreamContext, JetStreamContextTelemetry]] = None
-
     def __init__(
         self,
         nats_servers: List[str],
         nats_creds: Optional[str] = None,
         dummy: bool = False,
     ):
-        self.nats_creds = nats_creds
-        self.nats_servers = nats_servers
         self.dummy = dummy
-        self._calls: List[Tuple[str, IndexMessage]] = []
-
-    async def disconnected_cb(self):
-        logger.info("Got disconnected from NATS!")
-
-    async def reconnected_cb(self):
-        # See who we are connected to on reconnect.
-        logger.info("Got reconnected to NATS {url}".format(url=self.nc.connected_url))
-
-    async def error_cb(self, e):
-        logger.error(
-            "There was an error connecting to NATS indexing: {}".format(e),
-            exc_info=True,
-        )
-
-    async def closed_cb(self):
-        logger.info("Connection is closed on NATS")
+        if dummy:
+            self._calls: List[Tuple[str, IndexMessage]] = []
+        else:
+            self.nats_connection_manager = NatsConnectionManager(
+                service_name="IndexingUtility",
+                nats_servers=nats_servers,
+                nats_creds=nats_creds,
+            )
 
     async def initialize(self, service_name: Optional[str] = None):
         if self.dummy:
             return
-
-        options: Dict[str, Any] = {
-            "error_cb": self.error_cb,
-            "closed_cb": self.closed_cb,
-            "reconnected_cb": self.reconnected_cb,
-        }
-
-        if self.nats_creds:
-            options["user_credentials"] = self.nats_creds
-
-        if len(self.nats_servers) > 0:
-            options["servers"] = self.nats_servers
-
-        self.nc = await nats.connect(**options)
-        self.js = get_traced_jetstream(self.nc, service_name or "nucliadb_indexing")
+        await self.nats_connection_manager.initialize()
 
     async def finalize(self):
-        if self.nc:
-            await self.nc.flush()
-            await self.nc.close()
-            self.nc = None
+        if self.dummy:
+            return
+        await self.nats_connection_manager.finalize()
 
     async def index(self, writer: IndexMessage, node: str) -> int:
         if self.dummy:
             self._calls.append((node, writer))
             return 0
 
-        if self.js is None:
-            raise AttributeError()
-
         subject = const.Streams.INDEX.subject.format(node=node)
-        res = await self.js.publish(subject, writer.SerializeToString())
+        res = await self.nats_connection_manager.js.publish(subject, writer.SerializeToString())
         logger.info(
             f" - Pushed message to index {subject}.  shard: {writer.shard}, txid: {writer.txid}  seqid: {res.seq}"  # noqa
         )

nucliadb_utils/tests/azure.py

@@ -17,16 +17,17 @@
 # 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/>.
 #
+from contextlib import ExitStack
 from dataclasses import dataclass
-from typing import Generator
+from typing import Any, Generator
+from unittest.mock import patch
 
 import pytest
-from pytest_docker_fixtures import images  # type: ignore
-from pytest_docker_fixtures.containers._base import BaseImage  # type: ignore
+from pytest_docker_fixtures import images  # type: ignore  # type: ignore
+from pytest_docker_fixtures.containers._base import BaseImage  # type: ignore  # type: ignore
 
+from nucliadb_utils.settings import FileBackendConfig, storage_settings
 from nucliadb_utils.storages.azure import AzureStorage
-from nucliadb_utils.store import MAIN
-from nucliadb_utils.utilities import Utility
 
 images.settings["azurite"] = {
     "image": "mcr.microsoft.com/azure-storage/azurite",
@@ -107,16 +108,28 @@ def azurite() -> Generator[AzuriteFixture, None, None]:
 
 
 @pytest.fixture(scope="function")
-async def azure_storage(azurite):
+def azure_storage_settings(azurite: AzuriteFixture) -> dict[str, Any]:
+    settings = {
+        "file_backend": FileBackendConfig.AZURE,
+        "azure_account_url": azurite.account_url,
+        "azure_connection_string": azurite.connection_string,
+    }
+    with ExitStack() as stack:
+        for key, value in settings.items():
+            context = patch.object(storage_settings, key, value)
+            stack.enter_context(context)
+
+        yield settings
+
+
+@pytest.fixture(scope="function")
+async def azure_storage(azurite, azure_storage_settings: dict[str, Any]):
+    assert storage_settings.azure_account_url is not None
+
     storage = AzureStorage(
-        account_url=azurite.account_url,
-        connection_string=azurite.connection_string,
+        account_url=storage_settings.azure_account_url,
+        connection_string=storage_settings.azure_connection_string,
     )
-    MAIN[Utility.STORAGE] = storage
     await storage.initialize()
-    try:
-        yield storage
-    finally:
-        await storage.finalize()
-        if Utility.STORAGE in MAIN:
-            del MAIN[Utility.STORAGE]
+    yield storage
+    await storage.finalize()

nucliadb_utils/tests/fixtures.py

@@ -22,6 +22,8 @@ import os
 import pytest
 from pytest_lazy_fixtures import lazy_fixture
 
+from nucliadb_utils.utilities import Utility, clean_utility, set_utility
+
 
 @pytest.fixture(scope="function")
 def onprem_nucliadb():
@@ -47,17 +49,10 @@ def get_testing_storage_backend(default="gcs"):
     return os.environ.get("TESTING_STORAGE_BACKEND", default)
 
 
-def lazy_storage_fixture():
+def lazy_storage_fixture(default="gcs"):
     backend = get_testing_storage_backend()
-    if backend == "gcs":
-        return [lazy_fixture.lf("gcs_storage")]
-    elif backend == "s3":
-        return [lazy_fixture.lf("s3_storage")]
-    elif backend == "local":
-        return [lazy_fixture.lf("local_storage")]
-    else:
-        print(f"Unknown storage backend {backend}, using gcs")
-        return [lazy_fixture.lf("gcs_storage")]
+    fixture_name = f"{backend}_storage"
+    return [lazy_fixture.lf(fixture_name)]
 
 
 @pytest.fixture(scope="function", params=lazy_storage_fixture())
@@ -65,4 +60,9 @@ async def storage(request):
     """
     Generic storage fixture that allows us to run the same tests for different storage backends.
     """
-    return request.param
+    storage_driver = request.param
+    set_utility(Utility.STORAGE, storage_driver)
+
+    yield storage_driver
+
+    clean_utility(Utility.STORAGE)

nucliadb_utils/tests/gcs.py

@@ -19,18 +19,20 @@
 #
 import re
 from concurrent.futures.thread import ThreadPoolExecutor
-from typing import Optional
+from contextlib import ExitStack
+from typing import Any, Optional
+from unittest.mock import patch
 
-import docker  # type: ignore
+import docker  # type: ignore  # type: ignore
 import pytest
 import requests
 from pytest_docker_fixtures import images  # type: ignore
 from pytest_docker_fixtures.containers._base import BaseImage  # type: ignore
 
+from nucliadb_utils.settings import FileBackendConfig, storage_settings
 from nucliadb_utils.storages.gcs import GCSStorage
-from nucliadb_utils.store import MAIN
+from nucliadb_utils.storages.settings import settings as extended_storage_settings
 from nucliadb_utils.tests import free_port
-from nucliadb_utils.utilities import Utility
 
 # IMPORTANT!
 # Without this, tests running in a remote docker host won't work
@@ -77,20 +79,42 @@ def gcs():
 
 
 @pytest.fixture(scope="function")
-async def gcs_storage(gcs):
+def gcs_storage_settings(gcs) -> dict[str, Any]:
+    settings = {
+        "file_backend": FileBackendConfig.GCS,
+        "gcs_endpoint_url": gcs,
+        "gcs_base64_creds": None,
+        "gcs_bucket": "test_{kbid}",
+        "gcs_location": "location",
+    }
+    extended_settings = {
+        "gcs_deadletter_bucket": "deadletters",
+        "gcs_indexing_bucket": "indexing",
+    }
+    with ExitStack() as stack:
+        for key, value in settings.items():
+            context = patch.object(storage_settings, key, value)
+            stack.enter_context(context)
+        for key, value in extended_settings.items():
+            context = patch.object(extended_storage_settings, key, value)
+            stack.enter_context(context)
+
+        yield settings | extended_settings
+
+
+@pytest.fixture(scope="function")
+async def gcs_storage(gcs, gcs_storage_settings: dict[str, Any]):
     storage = GCSStorage(
-        account_credentials=None,
-        bucket="test_{kbid}",
-        location="location",
-        project="project",
+        url=storage_settings.gcs_endpoint_url,
+        account_credentials=storage_settings.gcs_base64_creds,
+        bucket=storage_settings.gcs_bucket,
+        location=storage_settings.gcs_location,
+        project=storage_settings.gcs_project,
         executor=ThreadPoolExecutor(1),
-        deadletter_bucket="deadletters",
-        indexing_bucket="indexing",
-        labels={},
-        url=gcs,
+        deadletter_bucket=extended_storage_settings.gcs_deadletter_bucket,
+        indexing_bucket=extended_storage_settings.gcs_indexing_bucket,
+        labels=storage_settings.gcs_bucket_labels,
     )
-    MAIN[Utility.STORAGE] = storage
     await storage.initialize()
     yield storage
     await storage.finalize()
-    MAIN.pop(Utility.STORAGE, None)

nucliadb_utils/tests/local.py

@@ -17,23 +17,36 @@
 # 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 tempfile
+from contextlib import ExitStack
+from pathlib import Path
+from typing import Any
+from unittest.mock import patch
 
 import pytest
 
+from nucliadb_utils.settings import FileBackendConfig, storage_settings
 from nucliadb_utils.storages.local import LocalStorage
-from nucliadb_utils.store import MAIN
-from nucliadb_utils.utilities import Utility
 
 
 @pytest.fixture(scope="function")
-async def local_storage():
-    folder = tempfile.TemporaryDirectory()
-    storage = LocalStorage(local_testing_files=folder.name)
+def local_storage_settings(tmp_path: Path) -> dict[str, Any]:
+    settings = {
+        "file_backend": FileBackendConfig.LOCAL,
+        "local_files": str((tmp_path / "blob").absolute()),
+    }
+    with ExitStack() as stack:
+        for key, value in settings.items():
+            context = patch.object(storage_settings, key, value)
+            stack.enter_context(context)
 
-    MAIN[Utility.STORAGE] = storage
+        yield settings
+
+
+@pytest.fixture(scope="function")
+async def local_storage(local_storage_settings: dict[str, Any]):
+    assert storage_settings.local_files is not None
+
+    storage = LocalStorage(local_testing_files=storage_settings.local_files)
     await storage.initialize()
     yield storage
     await storage.finalize()
-    folder.cleanup()
-    MAIN.pop(Utility.STORAGE, None)

nucliadb_utils/tests/s3.py

@@ -17,14 +17,18 @@
 # 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/>.
 #
+from contextlib import ExitStack
+from typing import Any
+from unittest.mock import patch
+
 import pytest
 import requests
 from pytest_docker_fixtures import images  # type: ignore
 from pytest_docker_fixtures.containers._base import BaseImage  # type: ignore
 
+from nucliadb_utils.settings import FileBackendConfig, storage_settings
 from nucliadb_utils.storages.s3 import S3Storage
-from nucliadb_utils.store import MAIN
-from nucliadb_utils.utilities import Utility
+from nucliadb_utils.storages.settings import settings as extended_storage_settings
 
 images.settings["s3"] = {
     "image": "localstack/localstack",
@@ -58,21 +62,49 @@ def s3():
 
 
 @pytest.fixture(scope="function")
-async def s3_storage(s3):
+async def s3_storage_settings(s3) -> dict[str, Any]:
+    settings = {
+        "file_backend": FileBackendConfig.S3,
+        "s3_endpoint": s3,
+        "s3_client_id": "",
+        "s3_client_secret": "",
+        "s3_ssl": False,
+        "s3_verify_ssl": False,
+        "s3_region_name": None,
+        "s3_bucket": "test-{kbid}",
+        "s3_bucket_tags": {
+            "testTag": "test",
+        },
+    }
+    extended_settings = {
+        "s3_indexing_bucket": "indexing",
+        "s3_deadletter_bucket": "deadletter",
+    }
+    with ExitStack() as stack:
+        for key, value in settings.items():
+            context = patch.object(storage_settings, key, value)
+            stack.enter_context(context)
+        for key, value in extended_settings.items():
+            context = patch.object(extended_storage_settings, key, value)
+            stack.enter_context(context)
+
+        yield settings | extended_settings
+
+
+@pytest.fixture(scope="function")
+async def s3_storage(s3, s3_storage_settings: dict[str, Any]):
     storage = S3Storage(
-        aws_client_id="",
-        aws_client_secret="",
-        deadletter_bucket="deadletter",
-        indexing_bucket="indexing",
-        endpoint_url=s3,
-        verify_ssl=False,
-        use_ssl=False,
-        region_name=None,
-        bucket="test-{kbid}",
-        bucket_tags={"testTag": "test"},
+        aws_client_id=storage_settings.s3_client_id,
+        aws_client_secret=storage_settings.s3_client_secret,
+        deadletter_bucket=extended_storage_settings.s3_deadletter_bucket,
+        indexing_bucket=extended_storage_settings.s3_indexing_bucket,
+        endpoint_url=storage_settings.s3_endpoint,
+        use_ssl=storage_settings.s3_ssl,
+        verify_ssl=storage_settings.s3_verify_ssl,
+        region_name=storage_settings.s3_region_name,
+        bucket=storage_settings.s3_bucket,
+        bucket_tags=storage_settings.s3_bucket_tags,
     )
     await storage.initialize()
-    MAIN[Utility.STORAGE] = storage
     yield storage
     await storage.finalize()
-    MAIN.pop(Utility.STORAGE, None)

nucliadb_utils/utilities.py

@@ -313,8 +313,8 @@ async def start_indexing_utility(service_name: Optional[str] = None) -> Indexing
 async def stop_indexing_utility():
     indexing_utility = get_indexing()
     if indexing_utility:
-        await indexing_utility.finalize()
         clean_utility(Utility.INDEXING)
+        await indexing_utility.finalize()
 
 
 def get_indexing() -> IndexingUtility:

{nucliadb_utils-5.0.0.post902.dist-info → nucliadb_utils-5.0.0.post906.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nucliadb_utils
-Version: 5.0.0.post902
+Version: 5.0.0.post906
 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.post902
-Requires-Dist: nucliadb-telemetry >=5.0.0.post902
+Requires-Dist: nucliadb-protos >=5.0.0.post906
+Requires-Dist: nucliadb-telemetry >=5.0.0.post906
 Provides-Extra: cache
 Requires-Dist: redis >=4.3.4 ; extra == 'cache'
 Requires-Dist: orjson >=3.6.7 ; extra == 'cache'

{nucliadb_utils-5.0.0.post902.dist-info → nucliadb_utils-5.0.0.post906.dist-info}/RECORD

@@ -7,7 +7,7 @@ nucliadb_utils/exceptions.py,sha256=y_3wk77WLVUtdo-5FtbBsdSkCtK_DsJkdWb5BoPn3qo,
 nucliadb_utils/featureflagging.py,sha256=Pxd9esUARDovXvQ6ZfvhooQ1Yf8GdMzXyH7kuEUzPlk,2846
 nucliadb_utils/grpc.py,sha256=apu0uePnkGHCAT7GRQ9YZfRYyFj26kJ440i8jitbM3U,3314
 nucliadb_utils/helpers.py,sha256=nPw8yod3hP-pxq80VF8QC36s7ygSg0dBUdfI-LatvCs,1600
-nucliadb_utils/indexing.py,sha256=QGR0d-Oy_rIgMKOqL01ZPZ_ZFTlL8Ed1UXE2U9nqvpo,3446
+nucliadb_utils/indexing.py,sha256=Luaqcar3CySpdYOFp6Q9Fyr8ZYwhYhaKRHQ_VGL78f8,2318
 nucliadb_utils/nats.py,sha256=zTAXECDXeCPtydk3F_6EMFDZ059kK0UYUU_tnWoxgXs,8208
 nucliadb_utils/partition.py,sha256=jBgy4Hu5Iwn4gjbPPcthSykwf-qNx-GcLAIwbzPd1d0,1157
 nucliadb_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -16,9 +16,9 @@ nucliadb_utils/settings.py,sha256=QR51SX0T17-_YofMNpci-nkI77l_CUWFy4H7i8hNOHU,79
 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=jjapoJvgZ-H0uMoThVK8P6EvCTTwL0kM_EEJY-Q22EU,16747
+nucliadb_utils/utilities.py,sha256=trAez4j2TYYT5n1qpimyHOEAnsQqDqD2qCFgVSDi184,16747
 nucliadb_utils/aiopynecone/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
-nucliadb_utils/aiopynecone/client.py,sha256=jlTLOdphrLZElKW9ajVzDcebN7CSAbjNyX6tnD37eqY,18721
+nucliadb_utils/aiopynecone/client.py,sha256=JsFmHmPjs73JU3ZQY3LmrpOma4oBAhuXxIHgQ987Yp8,19464
 nucliadb_utils/aiopynecone/exceptions.py,sha256=hFhq-UEY4slqNWjObXr_LPnRf_AQ1vpcG4SF2XRFd1E,2873
 nucliadb_utils/aiopynecone/models.py,sha256=B_ihJhHZGp3ivQVUxhV49uoUnHe1PLDKxTgHNbHgSS0,2937
 nucliadb_utils/audit/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
@@ -57,15 +57,15 @@ nucliadb_utils/storages/storage.py,sha256=gknIjRiHZ_f0EhTVYKVRgT4VqMlgDy9Ia6Av_1
 nucliadb_utils/storages/utils.py,sha256=8g2rIwJeYIumQLOB47Yw1rx3twlhRB_cJxer65QfZmk,1479
 nucliadb_utils/tests/__init__.py,sha256=Oo9CAE7B0eW5VHn8sHd6o30SQzOWUhktLPRXdlDOleA,1456
 nucliadb_utils/tests/asyncbenchmark.py,sha256=x4be2IwCawle9zWgMOJkmwoUwk5p1tv7cLQGmybkEOg,10587
-nucliadb_utils/tests/azure.py,sha256=7viGeUPC-HnRn7PG6cyDe8HhRsgOoAsU6tcuav3gl1A,3796
-nucliadb_utils/tests/fixtures.py,sha256=rmix1VGpPULBxJd_5ScgVD4Z0nRrkNOVt-uTW_WoURU,2144
-nucliadb_utils/tests/gcs.py,sha256=Ii8BCHUAAxFIzX67pKTRFRgbqv3FJ6DrPAdAx2Xod1Y,3036
+nucliadb_utils/tests/azure.py,sha256=uf1Ltt1sHyoN0Yt5QwkAm7GZxx-SXST1JdB4x3P_dEY,4372
+nucliadb_utils/tests/fixtures.py,sha256=b-e6Ciewh7GSh9rriG01bN9GiMW6xbGgrp3KiX7HNiY,2089
+nucliadb_utils/tests/gcs.py,sha256=Bx-kxf2NoYYeyNFPpBFxbRN8kIiYFpELEvqG0V1_9Ks,4183
 nucliadb_utils/tests/indexing.py,sha256=YW2QhkhO9Q_8A4kKWJaWSvXvyQ_AiAwY1VylcfVQFxk,1513
-nucliadb_utils/tests/local.py,sha256=c3gZJJWmvOftruJkIQIwB3q_hh3uxEhqGIAVWim1Bbk,1343
+nucliadb_utils/tests/local.py,sha256=7nuP8EFUAiA8ZH50R1iPV9EUXBySQxOanVm3Zht_e0g,1835
 nucliadb_utils/tests/nats.py,sha256=xqpww4jZjTKY9oPGlJdDJG67L3FIBQsa9qDHxILR8r8,7687
-nucliadb_utils/tests/s3.py,sha256=YB8QqDaBXxyhHonEHmeBbRRDmvB7sTOaKBSi8KBGokg,2330
-nucliadb_utils-5.0.0.post902.dist-info/METADATA,sha256=JP1HduOUr1UeizdHqI-9s1D70XM2KzRZBHdkzzYldL8,2073
-nucliadb_utils-5.0.0.post902.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
-nucliadb_utils-5.0.0.post902.dist-info/top_level.txt,sha256=fE3vJtALTfgh7bcAWcNhcfXkNPp_eVVpbKK-2IYua3E,15
-nucliadb_utils-5.0.0.post902.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-nucliadb_utils-5.0.0.post902.dist-info/RECORD,,
+nucliadb_utils/tests/s3.py,sha256=IdMxK_cNdSHLvO1u8BwsKFzD87Hk1MVPDZ57zx6h-rA,3656
+nucliadb_utils-5.0.0.post906.dist-info/METADATA,sha256=GGSNxtcd_ycKhtG-WGcGGOZfIDhNGB0wRV40SUpnaHs,2073
+nucliadb_utils-5.0.0.post906.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+nucliadb_utils-5.0.0.post906.dist-info/top_level.txt,sha256=fE3vJtALTfgh7bcAWcNhcfXkNPp_eVVpbKK-2IYua3E,15
+nucliadb_utils-5.0.0.post906.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+nucliadb_utils-5.0.0.post906.dist-info/RECORD,,