nucliadb 6.3.5.post4023__py3-none-any.whl → 6.3.5.post4026__py3-none-any.whl

nucliadb/common/cache.py

@@ -0,0 +1,183 @@
+# 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 asyncio
+from abc import ABC, abstractmethod
+from contextvars import ContextVar
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Generic, Optional, TypeVar
+
+from lru import LRU
+
+from nucliadb.ingest.orm.resource import Resource as ResourceORM
+from nucliadb_protos.utils_pb2 import ExtractedText
+from nucliadb_telemetry.metrics import Counter, Gauge
+
+# specific metrics per cache type
+cached_resources = Gauge("nucliadb_cached_resources")
+cached_extracted_texts = Gauge("nucliadb_cached_extracted_texts")
+resource_cache_ops = Counter("nucliadb_resource_cache_ops", labels={"type": ""})
+extracted_text_cache_ops = Counter("nucliadb_extracted_text_cache_ops", labels={"type": ""})
+
+
+T = TypeVar("T")
+
+
+@dataclass
+class CacheMetrics:
+    _cache_size: Gauge
+    ops: Counter
+
+
+class Cache(Generic[T], ABC):
+    """Low-level bounded cache implementation with access to per-key async locks
+    in case cache users want to lock concurrent access.
+
+    This cache is measured using a mandatory metric all subclasses must define.
+
+    """
+
+    def __init__(self, cache_size: int) -> None:
+        self.cache: LRU[str, T] = LRU(cache_size, callback=self._evicted_callback)
+        self.locks: dict[str, asyncio.Lock] = {}
+
+    def _evicted_callback(self, key: str, value: T):
+        self.locks.pop(key, None)
+        self.metrics.ops.inc({"type": "evict"})
+
+    def get(self, key: str) -> Optional[T]:
+        return self.cache.get(key)
+
+    # Get a lock for a specific key. Locks will be evicted at the same time as
+    # key-value pairs
+    def get_lock(self, key: str) -> asyncio.Lock:
+        return self.locks.setdefault(key, asyncio.Lock())
+
+    def set(self, key: str, value: T):
+        len_before = len(self.cache)
+
+        self.cache[key] = value
+
+        len_after = len(self.cache)
+        if len_after - len_before > 0:
+            self.metrics._cache_size.inc(len_after - len_before)
+
+    def contains(self, key: str) -> bool:
+        return key in self.cache
+
+    def clear(self):
+        self.metrics._cache_size.dec(len(self.cache))
+        self.cache.clear()
+        self.locks.clear()
+
+    def __del__(self):
+        # we want to clear the cache before deleting the object and set the
+        # metric appropriately
+        self.clear()
+
+    @abstractmethod
+    @cached_property
+    def metrics(self) -> CacheMetrics: ...
+
+
+class ResourceCache(Cache[ResourceORM]):
+    metrics = CacheMetrics(
+        _cache_size=cached_resources,
+        ops=resource_cache_ops,
+    )
+
+    # This cache size is an arbitrary number, once we have a metric in place and
+    # we analyze memory consumption, we can adjust it with more knoweldge
+    def __init__(self, cache_size: int = 128) -> None:
+        super().__init__(cache_size)
+
+
+class ExtractedTextCache(Cache[ExtractedText]):
+    """
+    Used to cache extracted text from a resource in memory during the process
+    of search results hydration.
+
+    This is needed to avoid fetching the same extracted text multiple times,
+    as matching text blocks are processed in parallel and the extracted text is
+    fetched for each field where the text block is found.
+    """
+
+    metrics = CacheMetrics(
+        _cache_size=cached_extracted_texts,
+        ops=extracted_text_cache_ops,
+    )
+
+    def __init__(self, cache_size: int = 128):
+        super().__init__(cache_size)
+
+
+# Global caches (per asyncio task)
+
+rcache: ContextVar[Optional[ResourceCache]] = ContextVar("rcache", default=None)
+etcache: ContextVar[Optional[ExtractedTextCache]] = ContextVar("etcache", default=None)
+
+
+# Cache management
+
+
+# Get or create a resource cache specific to the current asyncio task (and all
+# its subtasks). If you spawn subtasks that use this cache, make sure to create
+# it in the parent task, otherwise each subtask will have its own independent
+# cache instance
+def get_or_create_resource_cache(clear: bool = False) -> ResourceCache:
+    cache: Optional[ResourceCache] = rcache.get()
+    if cache is None or clear:
+        cache = ResourceCache()
+        rcache.set(cache)
+    return cache
+
+
+def get_resource_cache() -> Optional[ResourceCache]:
+    return rcache.get()
+
+
+def set_resource_cache() -> None:
+    cache = ResourceCache()
+    rcache.set(cache)
+
+
+# Delete resource cache and all its content
+def delete_resource_cache() -> None:
+    cache = rcache.get()
+    if cache is not None:
+        rcache.set(None)
+        del cache
+
+
+def get_extracted_text_cache() -> Optional[ExtractedTextCache]:
+    return etcache.get()
+
+
+def set_extracted_text_cache() -> None:
+    value = ExtractedTextCache()
+    etcache.set(value)
+
+
+def delete_extracted_text_cache() -> None:
+    cache = etcache.get()
+    if cache is not None:
+        etcache.set(None)
+        del cache

nucliadb/ingest/orm/processor/processor.py

@@ -354,7 +354,7 @@ class Processor:
                         rid=uuid,
                         source=message.source,
                     )
-                    logger.warning("This message did not modify the resource")
+                    logger.info("This message did not modify the resource")
             except (
                 asyncio.TimeoutError,
                 asyncio.CancelledError,

nucliadb/search/search/cache.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/>.
 
-import asyncio
 import contextlib
 import logging
-from contextvars import ContextVar
 from typing import Optional
 
-from lru import LRU
-
+from nucliadb.common.cache import (
+    delete_extracted_text_cache,
+    delete_resource_cache,
+    get_extracted_text_cache,
+    get_resource_cache,
+    set_extracted_text_cache,
+    set_resource_cache,
+)
 from nucliadb.common.ids import FieldId
 from nucliadb.common.maindb.utils import get_driver
 from nucliadb.ingest.fields.base import Field
@@ -32,51 +36,10 @@ from nucliadb.ingest.orm.knowledgebox import KnowledgeBox as KnowledgeBoxORM
 from nucliadb.ingest.orm.resource import Resource as ResourceORM
 from nucliadb.search import SERVICE_NAME
 from nucliadb_protos.utils_pb2 import ExtractedText
-from nucliadb_telemetry import metrics
 from nucliadb_utils.utilities import get_storage
 
 logger = logging.getLogger(__name__)
 
-rcache: ContextVar[Optional[dict[str, ResourceORM]]] = ContextVar("rcache", default=None)
-etcache: ContextVar[Optional["ExtractedTextCache"]] = ContextVar("etcache", default=None)
-
-
-RESOURCE_LOCKS: dict[str, asyncio.Lock] = LRU(1000)  # type: ignore
-RESOURCE_CACHE_OPS = metrics.Counter("nucliadb_resource_cache_ops", labels={"type": ""})
-EXTRACTED_CACHE_OPS = metrics.Counter("nucliadb_extracted_text_cache_ops", labels={"type": ""})
-
-
-def set_extracted_text_cache() -> None:
-    value = ExtractedTextCache()
-    etcache.set(value)
-
-
-def get_extracted_text_cache() -> Optional["ExtractedTextCache"]:
-    return etcache.get()
-
-
-def clear_extracted_text_cache() -> None:
-    value = etcache.get()
-    if value is not None:
-        value.clear()
-        etcache.set(None)
-
-
-def set_resource_cache() -> None:
-    value: dict[str, ResourceORM] = {}
-    rcache.set(value)
-
-
-def get_resource_cache() -> Optional[dict[str, ResourceORM]]:
-    return rcache.get()
-
-
-def clear_resource_cache() -> None:
-    value = rcache.get()
-    if value is not None:
-        value.clear()
-        rcache.set(None)
-
 
 async def get_resource(kbid: str, uuid: str) -> Optional[ResourceORM]:
     """
@@ -86,22 +49,18 @@ async def get_resource(kbid: str, uuid: str) -> Optional[ResourceORM]:
 
     resource_cache = get_resource_cache()
     if resource_cache is None:
-        RESOURCE_CACHE_OPS.inc({"type": "miss"})
         logger.warning("Resource cache not set")
         return await _orm_get_resource(kbid, uuid)
 
-    if uuid not in RESOURCE_LOCKS:
-        RESOURCE_LOCKS[uuid] = asyncio.Lock()
-
-    async with RESOURCE_LOCKS[uuid]:
-        if uuid not in resource_cache:
-            RESOURCE_CACHE_OPS.inc({"type": "miss"})
+    async with resource_cache.get_lock(uuid):
+        if not resource_cache.contains(uuid):
+            resource_cache.metrics.ops.inc({"type": "miss"})
             orm_resource = await _orm_get_resource(kbid, uuid)
         else:
-            RESOURCE_CACHE_OPS.inc({"type": "hit"})
+            resource_cache.metrics.ops.inc({"type": "hit"})
 
         if orm_resource is not None:
-            resource_cache[uuid] = orm_resource
+            resource_cache.set(uuid, orm_resource)
         else:
             orm_resource = resource_cache.get(uuid)
 
@@ -115,59 +74,30 @@ async def _orm_get_resource(kbid: str, uuid: str) -> Optional[ResourceORM]:
         return await kb.get(uuid)
 
 
-class ExtractedTextCache:
-    """
-    Used to cache extracted text from a resource in memory during the process
-    of search results hydration.
-
-    This is needed to avoid fetching the same extracted text multiple times,
-    as matching text blocks are processed in parallel and the extracted text is
-    fetched for each field where the text block is found.
-    """
-
-    def __init__(self):
-        self.locks = {}
-        self.values = {}
-
-    def get_value(self, key: str) -> Optional[ExtractedText]:
-        return self.values.get(key)
-
-    def get_lock(self, key: str) -> asyncio.Lock:
-        return self.locks.setdefault(key, asyncio.Lock())
-
-    def set_value(self, key: str, value: ExtractedText) -> None:
-        self.values[key] = value
-
-    def clear(self):
-        self.values.clear()
-        self.locks.clear()
-
-
 async def get_field_extracted_text(field: Field) -> Optional[ExtractedText]:
     cache = get_extracted_text_cache()
     if cache is None:
         logger.warning("Extracted text cache not set")
-        EXTRACTED_CACHE_OPS.inc({"type": "miss"})
         return await field.get_extracted_text()
 
     key = f"{field.kbid}/{field.uuid}/{field.id}"
-    extracted_text = cache.get_value(key)
+    extracted_text = cache.get(key)
     if extracted_text is not None:
-        EXTRACTED_CACHE_OPS.inc({"type": "hit"})
+        cache.metrics.ops.inc({"type": "hit"})
         return extracted_text
 
     async with cache.get_lock(key):
         # Check again in case another task already fetched it
-        extracted_text = cache.get_value(key)
+        extracted_text = cache.get(key)
         if extracted_text is not None:
-            EXTRACTED_CACHE_OPS.inc({"type": "hit"})
+            cache.metrics.ops.inc({"type": "hit"})
             return extracted_text
 
-        EXTRACTED_CACHE_OPS.inc({"type": "miss"})
+        cache.metrics.ops.inc({"type": "miss"})
         extracted_text = await field.get_extracted_text()
         if extracted_text is not None:
             # Only cache if we actually have extracted text
-            cache.set_value(key, extracted_text)
+            cache.set(key, extracted_text)
         return extracted_text
 
 
@@ -202,5 +132,5 @@ def request_caches():
     try:
         yield
     finally:
-        clear_resource_cache()
-        clear_extracted_text_cache()
+        delete_resource_cache()
+        delete_extracted_text_cache()

nucliadb/train/generators/field_streaming.py

@@ -72,7 +72,9 @@ async def generate_field_streaming_payloads(
 
     for status in trainset.filter.status:
         request.filter.labels.append(f"/n/s/{status}")
+
     total = 0
+    resources = set()
 
     async for document_item in node.stream_get_fields(request):
         text_labels = []
@@ -81,6 +83,7 @@ async def generate_field_streaming_payloads(
 
         field_id = f"{document_item.uuid}{document_item.field}"
         total += 1
+        resources.add(document_item.uuid)
 
         field_parts = document_item.field.split("/")
         if len(field_parts) == 3:
@@ -117,6 +120,27 @@ async def generate_field_streaming_payloads(
 
         yield tl
 
+        if total % 1000 == 0:
+            logger.info(
+                "Field streaming in progress",
+                extra={
+                    "fields": total,
+                    "resources": len(resources),
+                    "kbid": kbid,
+                    "shard_replica_id": shard_replica_id,
+                },
+            )
+
+    logger.info(
+        "Field streaming finished",
+        extra={
+            "fields": total,
+            "resources": len(resources),
+            "kbid": kbid,
+            "shard_replica_id": shard_replica_id,
+        },
+    )
+
 
 async def get_field_text(kbid: str, rid: str, field: str, field_type: str) -> Optional[ExtractedText]:
     orm_resource = await get_resource_from_cache_or_db(kbid, rid)

nucliadb/train/generators/utils.py

@@ -18,9 +18,9 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 
-from contextvars import ContextVar
 from typing import Any, AsyncGenerator, AsyncIterator, Optional, Type
 
+from nucliadb.common.cache import get_or_create_resource_cache
 from nucliadb.common.ids import FIELD_TYPE_STR_TO_PB
 from nucliadb.common.maindb.utils import get_driver
 from nucliadb.ingest.orm.knowledgebox import KnowledgeBox as KnowledgeBoxORM
@@ -29,29 +29,21 @@ from nucliadb.train import SERVICE_NAME, logger
 from nucliadb.train.types import T
 from nucliadb_utils.utilities import get_storage
 
-rcache: ContextVar[Optional[dict[str, ResourceORM]]] = ContextVar("rcache", default=None)
-
-
-def get_resource_cache(clear: bool = False) -> dict[str, ResourceORM]:
-    value: Optional[dict[str, ResourceORM]] = rcache.get()
-    if value is None or clear:
-        value = {}
-        rcache.set(value)
-    return value
-
 
 async def get_resource_from_cache_or_db(kbid: str, uuid: str) -> Optional[ResourceORM]:
-    resouce_cache = get_resource_cache()
+    resource_cache = get_or_create_resource_cache()
     orm_resource: Optional[ResourceORM] = None
-    if uuid not in resouce_cache:
+    if not resource_cache.contains(uuid):
+        resource_cache.metrics.ops.inc({"type": "miss"})
         storage = await get_storage(service_name=SERVICE_NAME)
         async with get_driver().transaction(read_only=True) as transaction:
             kb = KnowledgeBoxORM(transaction, storage, kbid)
             orm_resource = await kb.get(uuid)
             if orm_resource is not None:
-                resouce_cache[uuid] = orm_resource
+                resource_cache.set(uuid, orm_resource)
     else:
-        orm_resource = resouce_cache.get(uuid)
+        resource_cache.metrics.ops.inc({"type": "hit"})
+        orm_resource = resource_cache.get(uuid)
     return orm_resource
 
 

{nucliadb-6.3.5.post4023.dist-info → nucliadb-6.3.5.post4026.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nucliadb
-Version: 6.3.5.post4023
+Version: 6.3.5.post4026
 Summary: NucliaDB
 Author-email: Nuclia <nucliadb@nuclia.com>
 License: AGPL
@@ -20,11 +20,11 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: <4,>=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: nucliadb-telemetry[all]>=6.3.5.post4023
-Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.3.5.post4023
-Requires-Dist: nucliadb-protos>=6.3.5.post4023
-Requires-Dist: nucliadb-models>=6.3.5.post4023
-Requires-Dist: nidx-protos>=6.3.5.post4023
+Requires-Dist: nucliadb-telemetry[all]>=6.3.5.post4026
+Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.3.5.post4026
+Requires-Dist: nucliadb-protos>=6.3.5.post4026
+Requires-Dist: nucliadb-models>=6.3.5.post4026
+Requires-Dist: nidx-protos>=6.3.5.post4026
 Requires-Dist: nucliadb-admin-assets>=1.0.0.post1224
 Requires-Dist: nuclia-models>=0.24.2
 Requires-Dist: uvicorn[standard]

{nucliadb-6.3.5.post4023.dist-info → nucliadb-6.3.5.post4026.dist-info}/RECORD

@@ -53,6 +53,7 @@ nucliadb/backups/settings.py,sha256=SyzsInj1BRbBI0atg5IXWbMbOZ_eVg4eSQ3IcnUhCxQ,
 nucliadb/backups/tasks.py,sha256=WkL1LgdYBHbV_A5ilyYv5p3zmXwxH68TDudytN5f7zk,4225
 nucliadb/backups/utils.py,sha256=_Vogjqcru5oqNZM-bZ0q7Ju79Bv1PD-LVFEa7Z-Q13I,1261
 nucliadb/common/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
+nucliadb/common/cache.py,sha256=4iZEfoXgpwTj5Yh25wnllJQWJ8TqefpVOH2y3Z6wjjE,5589
 nucliadb/common/constants.py,sha256=QpigxJh_CtD85Evy0PtV5cVq6x0U_f9xfIcXz1ymkUg,869
 nucliadb/common/counters.py,sha256=8lOi3A2HeLDDlcNaS2QT1SfD3350VPBjiY3FkmHH1V8,977
 nucliadb/common/ids.py,sha256=4QjoIofes_vtKj2HsFWZf8VVIVWXxdkYtLpx1n618Us,8239
@@ -155,7 +156,7 @@ nucliadb/ingest/orm/processor/__init__.py,sha256=Aqd9wCNTvggkMkCY3WvoI8spdr94Jnq
 nucliadb/ingest/orm/processor/auditing.py,sha256=TeYhXGJRyQ7ROytbb2u8R0fIh_FYi3HgTu3S1ribY3U,4623
 nucliadb/ingest/orm/processor/data_augmentation.py,sha256=v-pj4GbBWSuO8dQyahs5UDr5ghsyfhCZDS0ftKd6ZYc,5179
 nucliadb/ingest/orm/processor/pgcatalog.py,sha256=H-OCRz0RuTUb80LZBxDowLA9V7ECv1DWiXlnzKW5XGI,3103
-nucliadb/ingest/orm/processor/processor.py,sha256=q2iBJJ_5SV_bxA3t5MrbV70iQhir94aFbjZjnYJzEAQ,33141
+nucliadb/ingest/orm/processor/processor.py,sha256=L2iKYTC_qh64pfl4joKQ0h7YaiskGq-fBJ4QtsDRTqw,33138
 nucliadb/ingest/orm/processor/sequence_manager.py,sha256=uqEphtI1Ir_yk9jRl2gPf7BlzzXWovbARY5MNZSBI_8,1704
 nucliadb/ingest/service/__init__.py,sha256=MME_G_ERxzJR6JW_hfE2qcfXpmpH1kdG-S0a-M0qRm8,2043
 nucliadb/ingest/service/exceptions.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
@@ -227,7 +228,7 @@ nucliadb/search/api/v1/resource/utils.py,sha256=-NjZqAQtFEXKpIh8ui5S26ItnJ5rzmmG
 nucliadb/search/requesters/__init__.py,sha256=itSI7dtTwFP55YMX4iK7JzdMHS5CQVUiB1XzQu4UBh8,833
 nucliadb/search/requesters/utils.py,sha256=cQZ4-NftiMljoWQ7-Zl7nWfr6u_FY8u_wc9kTvKQcAg,6999
 nucliadb/search/search/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
-nucliadb/search/search/cache.py,sha256=n9vkN6Y6Xnr2RBJyoH0WzjzGTJOMfKekU9tfPTWWCPc,6810
+nucliadb/search/search/cache.py,sha256=s5wfWq40I4HOLtsKxe3Q5vanL9-3J5T8e0G3yvQ7OKg,4817
 nucliadb/search/search/cut.py,sha256=ytY0_GY7ocNjfxTb4aosxEp4ZfhQNDP--JkhEMGD298,1153
 nucliadb/search/search/exceptions.py,sha256=klGLgAGGrXcSGix_W6418ZBMqDchAIGjN77ofkOScEI,1039
 nucliadb/search/search/fetch.py,sha256=XJHIFnZmXM_8Kb37lb4lg1GYG7cZ1plT-qAIb_QziX4,6184
@@ -313,14 +314,14 @@ nucliadb/train/api/v1/shards.py,sha256=GJRnQe8P-7_VTIN1oxVmxlrDA08qVN7opEZdbF4Wx
 nucliadb/train/api/v1/trainset.py,sha256=kpnpDgiMWr1FKHZJgwH7hue5kzilA8-i9X0YHlNeHuU,2113
 nucliadb/train/generators/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/train/generators/field_classifier.py,sha256=yatj7U-LHRN5xTR6XsYz_3acIAUKTcpkNZcZaSY8MtE,3482
-nucliadb/train/generators/field_streaming.py,sha256=kjwg4VNiROVqVDN--mRd4ylLw55Sg2VYxKRDdbmpYSM,5398
+nucliadb/train/generators/field_streaming.py,sha256=BeIiekrkrd2WkPf9_vlJkC9Qxe6bfVFmyu3VvTdzxVM,6034
 nucliadb/train/generators/image_classifier.py,sha256=B4P88JfpjMcAZIPzlSOYaGseq5NgfssEr_Ecvlprr3g,1859
 nucliadb/train/generators/paragraph_classifier.py,sha256=0pOZYcT1cAmG7gjSD1HIUaMM5T3Ag-96iUTXRhiV8MI,2761
 nucliadb/train/generators/paragraph_streaming.py,sha256=dsM7a5hBd2iokvFuxnZhQeko4Jad6djyP2p3tevku8A,3586
 nucliadb/train/generators/question_answer_streaming.py,sha256=P7-de4W4yW2mgEQ82fF2OZVyx6QJHXezY52qDciDcmw,5680
 nucliadb/train/generators/sentence_classifier.py,sha256=DuvXfnWvLhklYR_qFGk2LqUyl2JE7CMVFwuHaPyC9Ys,5121
 nucliadb/train/generators/token_classifier.py,sha256=0848GqoXh8ywU82cPUrkzOM53-lZ1MVCw--8yDABigY,9557
-nucliadb/train/generators/utils.py,sha256=1uSELmM4CpKy9jWp6j_u7_n_KR-udRNkes4UmPMOCcI,3907
+nucliadb/train/generators/utils.py,sha256=bArGm3MyFvHAIImhnQ3GZ6u2mZAhmRd3t3AbfDK-Aeg,3756
 nucliadb/writer/__init__.py,sha256=S298mrZL3vr62OrBqi97mdLxgR5cReMlRJgnaQHZV7s,1304
 nucliadb/writer/app.py,sha256=ABBO8-u4pDAa61b3mCdD0TFhuHAYcxMkgpZSGgWARuE,2736
 nucliadb/writer/back_pressure.py,sha256=JaiC2JAugVA92gDHzABZFiuQexiOKZC9C-3Jn9VF-M0,17898
@@ -360,8 +361,8 @@ nucliadb/writer/tus/local.py,sha256=7jYa_w9b-N90jWgN2sQKkNcomqn6JMVBOVeDOVYJHto,
 nucliadb/writer/tus/s3.py,sha256=vF0NkFTXiXhXq3bCVXXVV-ED38ECVoUeeYViP8uMqcU,8357
 nucliadb/writer/tus/storage.py,sha256=ToqwjoYnjI4oIcwzkhha_MPxi-k4Jk3Lt55zRwaC1SM,2903
 nucliadb/writer/tus/utils.py,sha256=MSdVbRsRSZVdkaum69_0wku7X3p5wlZf4nr6E0GMKbw,2556
-nucliadb-6.3.5.post4023.dist-info/METADATA,sha256=wqYdZmrMCVh5aJdvQ0wreuv7Iy3QOL8LAmLuMCeeP40,4301
-nucliadb-6.3.5.post4023.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nucliadb-6.3.5.post4023.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
-nucliadb-6.3.5.post4023.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
-nucliadb-6.3.5.post4023.dist-info/RECORD,,
+nucliadb-6.3.5.post4026.dist-info/METADATA,sha256=pxJ_dFn3jLaLxEXtBXk93R87X5pt9NFdaWNvgBsfvag,4301
+nucliadb-6.3.5.post4026.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nucliadb-6.3.5.post4026.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
+nucliadb-6.3.5.post4026.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
+nucliadb-6.3.5.post4026.dist-info/RECORD,,