nucliadb-utils 4.0.3.post586__py3-none-any.whl → 4.0.3.post589__py3-none-any.whl

nucliadb_utils/asyncio_utils.py

@@ -62,9 +62,7 @@ class ConcurrentRunner:
         return results
 
 
-async def run_concurrently(
-    tasks: list[Coroutine], max_concurrent: Optional[int] = None
-) -> list[Any]:
+async def run_concurrently(tasks: list[Coroutine], max_concurrent: Optional[int] = None) -> list[Any]:
     """
     Runs a list of coroutines concurrently, with a maximum number of tasks running.
     Returns the results of the coroutines in the order they were scheduled.

nucliadb_utils/audit/audit.py

@@ -20,6 +20,7 @@
 from typing import List, Optional
 
 from google.protobuf.timestamp_pb2 import Timestamp
+
 from nucliadb_protos.audit_pb2 import (
     AuditField,
     AuditKBCounter,

nucliadb_utils/audit/basic.py

@@ -20,6 +20,7 @@
 from typing import List, Optional
 
 from google.protobuf.timestamp_pb2 import Timestamp
+
 from nucliadb_protos.audit_pb2 import (
     AuditField,
     AuditKBCounter,
@@ -29,7 +30,6 @@ from nucliadb_protos.audit_pb2 import (
 from nucliadb_protos.nodereader_pb2 import SearchRequest
 from nucliadb_protos.resources_pb2 import FieldID
 from nucliadb_protos.writer_pb2 import BrokerMessage
-
 from nucliadb_utils import logger
 from nucliadb_utils.audit.audit import AuditStorage
 
@@ -51,9 +51,7 @@ class BasicAuditStorage(AuditStorage):
         audit_fields: Optional[List[AuditField]] = None,
         kb_counter: Optional[AuditKBCounter] = None,
     ):
-        logger.debug(
-            f"AUDIT {audit_type} {kbid} {user} {origin} {rid} {audit_fields} {kb_counter}"
-        )
+        logger.debug(f"AUDIT {audit_type} {kbid} {user} {origin} {rid} {audit_fields} {kb_counter}")
 
     def report_resources(
         self,

nucliadb_utils/audit/stream.py

@@ -25,6 +25,8 @@ import backoff
 import mmh3
 import nats
 from google.protobuf.timestamp_pb2 import Timestamp
+from opentelemetry.trace import format_trace_id, get_current_span
+
 from nucliadb_protos.audit_pb2 import (
     AuditField,
     AuditKBCounter,
@@ -34,8 +36,6 @@ from nucliadb_protos.audit_pb2 import (
 )
 from nucliadb_protos.nodereader_pb2 import SearchRequest
 from nucliadb_protos.resources_pb2 import FieldID
-from opentelemetry.trace import format_trace_id, get_current_span
-
 from nucliadb_utils import logger
 from nucliadb_utils.audit.audit import AuditStorage
 from nucliadb_utils.nats import get_traced_jetstream
@@ -89,9 +89,7 @@ class StreamAuditStorage(AuditStorage):
         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 audit: {}".format(e), exc_info=True
-        )
+        logger.error("There was an error connecting to NATS audit: {}".format(e), exc_info=True)
 
     async def closed_cb(self):
         logger.info("Connection is closed on NATS")
@@ -149,9 +147,7 @@ class StreamAuditStorage(AuditStorage):
     async def send(self, message: AuditRequest):
         self.queue.put_nowait(message)
 
-    @backoff.on_exception(
-        backoff.expo, (Exception,), jitter=backoff.random_jitter, max_tries=4
-    )
+    @backoff.on_exception(backoff.expo, (Exception,), jitter=backoff.random_jitter, max_tries=4)
     async def _send(self, message: AuditRequest):
         if self.js is None:  # pragma: no cover
             raise AttributeError()
@@ -205,9 +201,7 @@ class StreamAuditStorage(AuditStorage):
                 account_id=None,
                 kb_id=kbid,
                 kb_source=KBSource.HOSTED,
-                storage=Storage(
-                    paragraphs=kb_counter.paragraphs, fields=kb_counter.fields
-                ),
+                storage=Storage(paragraphs=kb_counter.paragraphs, fields=kb_counter.fields),
             )
 
         auditrequest.trace_id = get_trace_id()

nucliadb_utils/authentication.py

@@ -56,9 +56,7 @@ class NucliaCloudAuthenticationBackend(AuthenticationBackend):
         self.roles_header = roles_header
         self.user_header = user_header
 
-    async def authenticate(
-        self, request: HTTPConnection
-    ) -> Optional[Tuple[AuthCredentials, BaseUser]]:
+    async def authenticate(self, request: HTTPConnection) -> Optional[Tuple[AuthCredentials, BaseUser]]:
         if self.roles_header not in request.headers:
             return None
         else:
@@ -97,9 +95,7 @@ def requires(
     elif isinstance(scopes, str):
         scopes_list = [scopes]
     elif isinstance(scopes, list):
-        scopes_list = [
-            scope.value if isinstance(scope, Enum) else scope for scope in scopes
-        ]
+        scopes_list = [scope.value if isinstance(scope, Enum) else scope for scope in scopes]
 
     def decorator(func: typing.Callable) -> typing.Callable:
         func.__required_scopes__ = scopes_list  # type: ignore
@@ -110,16 +106,12 @@ def requires(
                 type = parameter.name
                 break
         else:
-            raise Exception(
-                f'No "request" or "websocket" argument on function "{func}"'
-            )
+            raise Exception(f'No "request" or "websocket" argument on function "{func}"')
 
         if type == "websocket":
             # Handle websocket functions. (Always async)
             @functools.wraps(func)
-            async def websocket_wrapper(
-                *args: typing.Any, **kwargs: typing.Any
-            ) -> None:
+            async def websocket_wrapper(*args: typing.Any, **kwargs: typing.Any) -> None:
                 websocket = kwargs.get("websocket", args[idx])
                 assert isinstance(websocket, WebSocket)
 
@@ -133,17 +125,13 @@ def requires(
         elif asyncio.iscoroutinefunction(func):
             # Handle async request/response functions.
             @functools.wraps(func)
-            async def async_wrapper(
-                *args: typing.Any, **kwargs: typing.Any
-            ) -> Response:
+            async def async_wrapper(*args: typing.Any, **kwargs: typing.Any) -> Response:
                 request = kwargs.get("request", None)
                 assert isinstance(request, Request)
 
                 if not has_required_scope(request, scopes_list):
                     if redirect is not None:
-                        return RedirectResponse(
-                            url=request.url_for(redirect), status_code=303
-                        )
+                        return RedirectResponse(url=request.url_for(redirect), status_code=303)
                     raise HTTPException(status_code=status_code)
                 return await func(*args, **kwargs)
 
@@ -161,9 +149,7 @@ def requires(
 
                 if not has_required_scope(request, scopes_list):
                     if redirect is not None:
-                        return RedirectResponse(
-                            url=request.url_for(redirect), status_code=303
-                        )
+                        return RedirectResponse(url=request.url_for(redirect), status_code=303)
                     raise HTTPException(status_code=status_code)
                 return func(*args, **kwargs)
 

nucliadb_utils/cache/nats.py

@@ -148,9 +148,7 @@ class NatsPubsub(PubSubDriver):
 
     async def reconnected_cb(self):
         # See who we are connected to on reconnect.
-        logger.info(
-            "Got reconnected NATS to {url}".format(url=self.nc.connected_url.netloc)
-        )
+        logger.info("Got reconnected NATS to {url}".format(url=self.nc.connected_url.netloc))
 
     async def error_cb(self, e):
         logger.info("There was an error connecting to NATS {}".format(e), exc_info=True)
@@ -169,9 +167,7 @@ class NatsPubsub(PubSubDriver):
         else:
             raise ErrConnectionClosed("Could not subscribe")
 
-    async def subscribe(
-        self, handler: Callback, key, group="", subscription_id: Optional[str] = None
-    ):
+    async def subscribe(self, handler: Callback, key, group="", subscription_id: Optional[str] = None):
         if subscription_id is None:
             subscription_id = key
 

nucliadb_utils/debug.py

@@ -54,10 +54,7 @@ def display_top(snapshot, key_type="lineno", limit=10):  # pragma: no cover
     print(f"Top {limit} lines")
     for index, stat in enumerate(top_stats[:limit], 1):
         frame = stat.traceback[0]
-        print(
-            "#%s: %s:%s: %.1f KiB"
-            % (index, frame.filename, frame.lineno, stat.size / 1024)
-        )
+        print("#%s: %s:%s: %.1f KiB" % (index, frame.filename, frame.lineno, stat.size / 1024))
         line = linecache.getline(frame.filename, frame.lineno).strip()
         if line:
             print("    %s" % line)

nucliadb_utils/fastapi/versioning.py

@@ -29,9 +29,7 @@ from starlette.routing import BaseRoute
 CallableT = TypeVar("CallableT", bound=Callable[..., Any])
 
 
-def version(
-    major: int, minor: int = 0
-) -> Callable[[CallableT], CallableT]:  # pragma: no cover
+def version(major: int, minor: int = 0) -> Callable[[CallableT], CallableT]:  # pragma: no cover
     def decorator(func: CallableT) -> CallableT:
         func._api_version = (major, minor)  # type: ignore
         return func
@@ -75,7 +73,10 @@ def VersionedFastAPI(
         prefix = prefix_format.format(major=major, minor=minor)
         semver = version_format.format(major=major, minor=minor)
         versioned_app = FastAPI(
-            title=app.title, description=app.description, version=semver, **kwargs  # type: ignore
+            title=app.title,
+            description=app.description,
+            version=semver,
+            **kwargs,  # type: ignore
         )
         for route in version_route_mapping[version]:
             for method in route.methods:

nucliadb_utils/featureflagging.py

@@ -72,9 +72,7 @@ class FlagService:
         else:
             self.flag_service = mrflagly.FlagService(url=settings.flag_settings_url)
 
-    def enabled(
-        self, flag_key: str, default: bool = False, context: Optional[dict] = None
-    ) -> bool:
+    def enabled(self, flag_key: str, default: bool = False, context: Optional[dict] = None) -> bool:
         if context is None:
             context = {}
         context["environment"] = running_settings.running_environment

nucliadb_utils/grpc.py

@@ -90,8 +90,6 @@ def get_traced_grpc_server(service_name: str, max_receive_message: int = 100):
             interceptors=[SentryInterceptor()],
         )
     else:
-        options = [
-            ("grpc.max_receive_message_length", max_receive_message * 1024 * 1024)
-        ]
+        options = [("grpc.max_receive_message_length", max_receive_message * 1024 * 1024)]
         server = aio.server(options=options)
     return server

nucliadb_utils/helpers.py

@@ -21,7 +21,7 @@ from typing import AsyncGenerator
 
 
 async def async_gen_lookahead(
-    gen: AsyncGenerator[bytes, None]
+    gen: AsyncGenerator[bytes, None],
 ) -> AsyncGenerator[tuple[bytes, bool], None]:
     """Async generator that yields the next chunk and whether it's the last one.
     Empty chunks are ignored.

nucliadb_utils/indexing.py

@@ -22,8 +22,8 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 import nats
 from nats.aio.client import Client
 from nats.js.client import JetStreamContext
-from nucliadb_protos.nodewriter_pb2 import IndexMessage
 
+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

nucliadb_utils/nats.py

@@ -100,9 +100,7 @@ class MessageProgressUpdater:
 class NatsConnectionManager:
     _nc: NATSClient
     _subscriptions: list[tuple[Subscription, Callable[[], Awaitable[None]]]]
-    _unhealthy_timeout = (
-        10  # needs to be unhealth for 10 seconds to be unhealthy and force exit
-    )
+    _unhealthy_timeout = 10  # needs to be unhealth for 10 seconds to be unhealthy and force exit
 
     def __init__(
         self,

nucliadb_utils/run.py

@@ -25,9 +25,7 @@ from typing import Awaitable, Callable
 logger = logging.getLogger(__name__)
 
 
-async def run_until_exit(
-    finalizers: list[Callable[[], Awaitable[None]]], sleep: float = 1.0
-):
+async def run_until_exit(finalizers: list[Callable[[], Awaitable[None]]], sleep: float = 1.0):
     exit_event = asyncio.Event()
 
     def handle_exit(*args):

nucliadb_utils/settings.py

@@ -98,9 +98,7 @@ class StorageSettings(BaseSettings):
     s3_max_pool_connections: int = 30
     s3_endpoint: Optional[str] = None
     s3_region_name: Optional[str] = None
-    s3_bucket: Optional[str] = Field(
-        default=None, description="KnowledgeBox S3 bucket name template"
-    )
+    s3_bucket: Optional[str] = Field(default=None, description="KnowledgeBox S3 bucket name template")
     s3_bucket_tags: Dict[str, str] = Field(
         default={},
         description="Map of tags with which S3 buckets will be tagged with: https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketTagging.html",  # noqa
@@ -125,13 +123,9 @@ storage_settings = StorageSettings()
 class NucliaSettings(BaseSettings):
     nuclia_service_account: Optional[str] = None
     nuclia_public_url: str = "https://{zone}.nuclia.cloud"
-    nuclia_processing_cluster_url: str = (
-        "http://processing-api.processing.svc.cluster.local:8080"
-    )
+    nuclia_processing_cluster_url: str = "http://processing-api.processing.svc.cluster.local:8080"
     nuclia_inner_predict_url: str = "http://predict.learning.svc.cluster.local:8080"
-    learning_internal_svc_base_url: str = (
-        "http://{service}.learning.svc.cluster.local:8080"
-    )
+    learning_internal_svc_base_url: str = "http://{service}.learning.svc.cluster.local:8080"
 
     nuclia_zone: str = "europe-1"
     onprem: bool = True

nucliadb_utils/signals.py

@@ -62,9 +62,7 @@ class Signal:
 
         awaitables = [
             cb(payload=payload)
-            for cb, _ in sorted(
-                self.callbacks.values(), key=lambda t: t[1], reverse=True
-            )
+            for cb, _ in sorted(self.callbacks.values(), key=lambda t: t[1], reverse=True)
         ]
 
         results = await asyncio.gather(*awaitables, return_exceptions=True)

nucliadb_utils/storages/exceptions.py

@@ -39,9 +39,7 @@ class InvalidOffset(Exception):
 class ResumableUploadGone(Exception):
     def __init__(self, text: str):
         self.text = text
-        super().__init__(
-            "Resumable upload is no longer available " "Google: \n " f"{text}"
-        )
+        super().__init__("Resumable upload is no longer available " "Google: \n " f"{text}")
 
 
 class CouldNotCopyNotFound(Exception):

nucliadb_utils/storages/gcs.py

@@ -35,8 +35,8 @@ import backoff
 import google.auth.transport.requests  # type: ignore
 import yarl
 from google.oauth2 import service_account  # type: ignore
-from nucliadb_protos.resources_pb2 import CloudFile
 
+from nucliadb_protos.resources_pb2 import CloudFile
 from nucliadb_telemetry import errors, metrics
 from nucliadb_telemetry.utils import setup_telemetry
 from nucliadb_utils import logger
@@ -117,9 +117,7 @@ class GCSStorageField(StorageField):
         origin_bucket_name: str,
         destination_bucket_name: str,
     ):
-        await self.copy(
-            origin_uri, destination_uri, origin_bucket_name, destination_bucket_name
-        )
+        await self.copy(origin_uri, destination_uri, origin_bucket_name, destination_bucket_name)
         await self.storage.delete_upload(origin_uri, origin_bucket_name)
 
     @backoff.on_exception(
@@ -163,9 +161,7 @@ class GCSStorageField(StorageField):
                 assert data["resource"]["name"] == destination_uri
 
     @storage_ops_observer.wrap({"type": "iter_data"})
-    async def iter_data(
-        self, range: Optional[Range] = None
-    ) -> AsyncGenerator[bytes, None]:
+    async def iter_data(self, range: Optional[Range] = None) -> AsyncGenerator[bytes, None]:
         attempt = 1
         while True:
             try:
@@ -243,9 +239,7 @@ class GCSStorageField(StorageField):
 
         if self.field is not None and self.field.upload_uri != "":
             # If there is a temporal url
-            await self.storage.delete_upload(
-                self.field.upload_uri, self.field.bucket_name
-            )
+            await self.storage.delete_upload(self.field.upload_uri, self.field.bucket_name)
 
         if self.field is not None and self.field.uri != "":
             field: CloudFile = CloudFile(
@@ -381,18 +375,13 @@ class GCSStorageField(StorageField):
         if self.field.old_uri not in ("", None):
             # Already has a file
             try:
-                await self.storage.delete_upload(
-                    self.field.old_uri, self.field.bucket_name
-                )
+                await self.storage.delete_upload(self.field.old_uri, self.field.bucket_name)
             except GoogleCloudException as e:
                 logger.warning(
-                    f"Could not delete existing google cloud file "
-                    f"with uri: {self.field.uri}: {e}"
+                    f"Could not delete existing google cloud file " f"with uri: {self.field.uri}: {e}"
                 )
         if self.field.upload_uri != self.key:
-            await self.move(
-                self.field.upload_uri, self.key, self.field.bucket_name, self.bucket
-            )
+            await self.move(self.field.upload_uri, self.key, self.field.bucket_name, self.bucket)
 
         self.field.uri = self.key
         self.field.ClearField("resumable_uri")
@@ -490,9 +479,7 @@ class GCSStorage(Storage):
         self._bucket_labels = labels or {}
         self._executor = executor
         self._creation_access_token = datetime.now()
-        self._upload_url = (
-            url + "/upload/storage/v1/b/{bucket}/o?uploadType=resumable"
-        )  # noqa
+        self._upload_url = url + "/upload/storage/v1/b/{bucket}/o?uploadType=resumable"  # noqa
         self.object_base_url = url + "/storage/v1/b"
         self._client = None
 
@@ -516,17 +503,13 @@ class GCSStorage(Storage):
             if self.deadletter_bucket is not None and self.deadletter_bucket != "":
                 await self.create_bucket(self.deadletter_bucket)
         except Exception:  # pragma: no cover
-            logger.exception(
-                f"Could not create bucket {self.deadletter_bucket}", exc_info=True
-            )
+            logger.exception(f"Could not create bucket {self.deadletter_bucket}", exc_info=True)
 
         try:
             if self.indexing_bucket is not None and self.indexing_bucket != "":
                 await self.create_bucket(self.indexing_bucket)
         except Exception:  # pragma: no cover
-            logger.exception(
-                f"Could not create bucket {self.indexing_bucket}", exc_info=True
-            )
+            logger.exception(f"Could not create bucket {self.indexing_bucket}", exc_info=True)
 
     async def finalize(self):
         await self.session.close()
@@ -549,9 +532,7 @@ class GCSStorage(Storage):
         if self.session is None:
             raise AttributeError()
         if uri:
-            url = "{}/{}/o/{}".format(
-                self.object_base_url, bucket_name, quote_plus(uri)
-            )
+            url = "{}/{}/o/{}".format(self.object_base_url, bucket_name, quote_plus(uri))
             headers = await self.get_access_headers()
             async with self.session.delete(url, headers=headers) as resp:
                 try:
@@ -562,8 +543,7 @@ class GCSStorage(Storage):
                 if resp.status not in (200, 204, 404):
                     if resp.status == 404:
                         logger.error(
-                            f"Attempt to delete not found gcloud: {data}, "
-                            f"status: {resp.status}",
+                            f"Attempt to delete not found gcloud: {data}, " f"status: {resp.status}",
                             exc_info=True,
                         )
                     else:
@@ -668,8 +648,7 @@ class GCSStorage(Storage):
                     logger.error("Not implemented")
                 elif resp.status == 404:
                     logger.error(
-                        f"Attempt to delete not found gcloud: {data}, "
-                        f"status: {resp.status}",
+                        f"Attempt to delete not found gcloud: {data}, " f"status: {resp.status}",
                         exc_info=True,
                     )
                 else:
@@ -706,9 +685,7 @@ class GCSStorage(Storage):
                     errors.capture_message(msg, "error", scope)
         return deleted, conflict
 
-    async def iterate_objects(
-        self, bucket: str, prefix: str
-    ) -> AsyncGenerator[ObjectInfo, None]:
+    async def iterate_objects(self, bucket: str, prefix: str) -> AsyncGenerator[ObjectInfo, None]:
         if self.session is None:
             raise AttributeError()
         url = "{}/{}/o".format(self.object_base_url, bucket)
@@ -755,9 +732,7 @@ def parse_object_metadata(object_data: dict[str, Any], key: str) -> ObjectMetada
         size = int(custom_size)
 
     # Parse content-type
-    content_type = (
-        custom_metadata.get("content_type") or object_data.get("contentType") or ""
-    )
+    content_type = custom_metadata.get("content_type") or object_data.get("contentType") or ""
 
     # Parse filename
     filename = custom_metadata.get("filename") or key.split("/")[-1]

nucliadb_utils/storages/local.py

@@ -27,8 +27,8 @@ from datetime import datetime
 from typing import AsyncGenerator, AsyncIterator, Optional
 
 import aiofiles
-from nucliadb_protos.resources_pb2 import CloudFile
 
+from nucliadb_protos.resources_pb2 import CloudFile
 from nucliadb_utils.storages import CHUNK_SIZE
 from nucliadb_utils.storages.storage import (
     ObjectInfo,
@@ -78,9 +78,7 @@ class LocalStorageField(StorageField):
         destination_path = f"{destination_bucket_path}/{destination_uri}"
         shutil.copy(origin_path, destination_path)
 
-    async def iter_data(
-        self, range: Optional[Range] = None
-    ) -> AsyncGenerator[bytes, None]:
+    async def iter_data(self, range: Optional[Range] = None) -> AsyncGenerator[bytes, None]:
         key = self.field.uri if self.field else self.key
         if self.field is None:
             bucket = self.bucket
@@ -89,7 +87,6 @@ class LocalStorageField(StorageField):
 
         path = self.storage.get_file_path(bucket, key)
         async with aiofiles.open(path, mode="rb") as resp:
-
             if range and range.start is not None:
                 # Seek to the start of the range
                 await resp.seek(range.start)
@@ -123,9 +120,7 @@ class LocalStorageField(StorageField):
     async def start(self, cf: CloudFile) -> CloudFile:
         if self.field is not None and self.field.upload_uri != "":
             # If there is a temporal url
-            await self.storage.delete_upload(
-                self.field.upload_uri, self.field.bucket_name
-            )
+            await self.storage.delete_upload(self.field.upload_uri, self.field.bucket_name)
 
         if self.field is not None and self.field.uri != "":
             field: CloudFile = CloudFile(
@@ -193,9 +188,7 @@ class LocalStorageField(StorageField):
             # Already has a file
             await self.storage.delete_upload(self.field.uri, self.field.bucket_name)
         if self.field.upload_uri != self.key:
-            await self.move(
-                self.field.upload_uri, self.key, self.field.bucket_name, self.bucket
-            )
+            await self.move(self.field.upload_uri, self.key, self.field.bucket_name, self.bucket)
 
         await self._handler.close()
         self.field.uri = self.key
@@ -284,9 +277,7 @@ class LocalStorage(Storage):
             deleted = False
         return deleted
 
-    async def iterate_objects(
-        self, bucket: str, prefix: str
-    ) -> AsyncGenerator[ObjectInfo, None]:
+    async def iterate_objects(self, bucket: str, prefix: str) -> AsyncGenerator[ObjectInfo, None]:
         for key in glob.glob(f"{bucket}/{prefix}*"):
             yield ObjectInfo(name=key)
 

nucliadb_utils/storages/nuclia.py

@@ -20,8 +20,8 @@
 from typing import Optional
 
 import aiohttp
-from nucliadb_protos.resources_pb2 import CloudFile
 
+from nucliadb_protos.resources_pb2 import CloudFile
 from nucliadb_utils.storages import CHUNK_SIZE
 
 

nucliadb_utils/storages/s3.py

@@ -29,8 +29,8 @@ import backoff
 import botocore  # type: ignore
 from aiobotocore.client import AioBaseClient  # type: ignore
 from aiobotocore.session import AioSession, get_session  # type: ignore
-from nucliadb_protos.resources_pb2 import CloudFile
 
+from nucliadb_protos.resources_pb2 import CloudFile
 from nucliadb_telemetry import errors
 from nucliadb_utils import logger
 from nucliadb_utils.storages.exceptions import UnparsableResponse
@@ -90,9 +90,7 @@ class S3StorageField(StorageField):
     ):
         range = range or Range()
         if range.any():
-            coro = self.storage._s3aioclient.get_object(
-                Bucket=bucket, Key=uri, Range=range.to_header()
-            )
+            coro = self.storage._s3aioclient.get_object(Bucket=bucket, Key=uri, Range=range.to_header())
         else:
             coro = self.storage._s3aioclient.get_object(Bucket=bucket, Key=uri)
         try:
@@ -104,9 +102,7 @@ class S3StorageField(StorageField):
             else:
                 raise
 
-    async def iter_data(
-        self, range: Optional[Range] = None
-    ) -> AsyncGenerator[bytes, None]:
+    async def iter_data(self, range: Optional[Range] = None) -> AsyncGenerator[bytes, None]:
         # Suports field and key based iter
         uri = self.field.uri if self.field else self.key
         if self.field is None:
@@ -235,9 +231,7 @@ class S3StorageField(StorageField):
                 self.field.ClearField("old_uri")
                 self.field.ClearField("old_bucket")
             except botocore.exceptions.ClientError:
-                logger.error(
-                    f"Referenced key {self.field.uri} could not be found", exc_info=True
-                )
+                logger.error(f"Referenced key {self.field.uri} could not be found", exc_info=True)
                 logger.warning("Error deleting object", exc_info=True)
 
         if self.field.resumable_uri != "":
@@ -264,8 +258,7 @@ class S3StorageField(StorageField):
             self.field.offset += 1
         part_info = {
             "Parts": [
-                {"PartNumber": part + 1, "ETag": etag}
-                for part, etag in enumerate(self.field.parts)
+                {"PartNumber": part + 1, "ETag": etag} for part, etag in enumerate(self.field.parts)
             ]
         }
         await self.storage._s3aioclient.complete_multipart_upload(
@@ -323,9 +316,7 @@ class S3StorageField(StorageField):
         origin_bucket_name: str,
         destination_bucket_name: str,
     ):
-        await self.copy(
-            origin_uri, destination_uri, origin_bucket_name, destination_bucket_name
-        )
+        await self.copy(origin_uri, destination_uri, origin_bucket_name, destination_bucket_name)
         await self.storage.delete_upload(origin_uri, origin_bucket_name)
 
     async def upload(self, iterator: AsyncIterator, origin: CloudFile) -> CloudFile:
@@ -373,9 +364,7 @@ class S3Storage(Storage):
             verify=verify_ssl,
             use_ssl=use_ssl,
             region_name=region_name,
-            config=aiobotocore.config.AioConfig(
-                None, max_pool_connections=max_pool_connections
-            ),
+            config=aiobotocore.config.AioConfig(None, max_pool_connections=max_pool_connections),
         )
         self._exit_stack = AsyncExitStack()
         self.bucket = bucket
@@ -420,9 +409,7 @@ class S3Storage(Storage):
         else:
             raise AttributeError("No valid uri")
 
-    async def iterate_objects(
-        self, bucket: str, prefix: str = "/"
-    ) -> AsyncGenerator[ObjectInfo, None]:
+    async def iterate_objects(self, bucket: str, prefix: str = "/") -> AsyncGenerator[ObjectInfo, None]:
         paginator = self._s3aioclient.get_paginator("list_objects")
         async for result in paginator.paginate(Bucket=bucket, Prefix=prefix):
             for item in result.get("Contents", []):
@@ -436,9 +423,7 @@ class S3Storage(Storage):
         return await bucket_exists(self._s3aioclient, bucket_name)
 
     async def create_bucket(self, bucket_name: str):
-        await create_bucket(
-            self._s3aioclient, bucket_name, self._bucket_tags, self._region_name
-        )
+        await create_bucket(self._s3aioclient, bucket_name, self._bucket_tags, self._region_name)
 
     async def schedule_delete_kb(self, kbid: str):
         bucket_name = self.get_bucket_name(kbid)
@@ -509,9 +494,7 @@ async def create_bucket(
 ):
     bucket_creation_options = {}
     if region_name is not None:
-        bucket_creation_options = {
-            "CreateBucketConfiguration": {"LocationConstraint": region_name}
-        }
+        bucket_creation_options = {"CreateBucketConfiguration": {"LocationConstraint": region_name}}
     # Create the bucket
     await client.create_bucket(Bucket=bucket_name, **bucket_creation_options)
 
@@ -521,8 +504,7 @@ async def create_bucket(
             Bucket=bucket_name,
             Tagging={
                 "TagSet": [
-                    {"Key": tag_key, "Value": tag_value}
-                    for tag_key, tag_value in bucket_tags.items()
+                    {"Key": tag_key, "Value": tag_value} for tag_key, tag_value in bucket_tags.items()
                 ]
             },
         )

nucliadb_utils/storages/storage.py

@@ -36,12 +36,12 @@ from typing import (
     cast,
 )
 
+from pydantic import BaseModel
+
 from nucliadb_protos.noderesources_pb2 import Resource as BrainResource
 from nucliadb_protos.nodewriter_pb2 import IndexMessage
 from nucliadb_protos.resources_pb2 import CloudFile
 from nucliadb_protos.writer_pb2 import BrokerMessage
-from pydantic import BaseModel
-
 from nucliadb_utils import logger
 from nucliadb_utils.helpers import async_gen_lookahead
 from nucliadb_utils.storages import CHUNK_SIZE
@@ -110,9 +110,7 @@ class StorageField(abc.ABC, metaclass=abc.ABCMeta):
     async def upload(self, iterator: AsyncIterator, origin: CloudFile) -> CloudFile: ...
 
     @abc.abstractmethod
-    async def iter_data(
-        self, range: Optional[Range] = None
-    ) -> AsyncGenerator[bytes, None]:
+    async def iter_data(self, range: Optional[Range] = None) -> AsyncGenerator[bytes, None]:
         raise NotImplementedError()
         yield b""
 
@@ -166,14 +164,10 @@ class Storage(abc.ABC, metaclass=abc.ABCMeta):
         # Delete all keys inside a resource
         bucket = self.get_bucket_name(kbid)
         resource_storage_base_path = STORAGE_RESOURCE.format(kbid=kbid, uuid=uuid)
-        async for object_info in self.iterate_objects(
-            bucket, resource_storage_base_path
-        ):
+        async for object_info in self.iterate_objects(bucket, resource_storage_base_path):
             await self.delete_upload(object_info.name, bucket)
 
-    async def deadletter(
-        self, message: BrokerMessage, seq: int, seqid: int, partition: str
-    ):
+    async def deadletter(self, message: BrokerMessage, seq: int, seqid: int, partition: str):
         if self.deadletter_bucket is None:
             logger.error("No Deadletter Bucket defined will not store the error")
             return
@@ -183,9 +177,7 @@ class Storage(abc.ABC, metaclass=abc.ABCMeta):
     def get_indexing_storage_key(
         self, *, kb: str, logical_shard: str, resource_uid: str, txid: Union[int, str]
     ):
-        return INDEXING_KEY.format(
-            kb=kb, shard=logical_shard, resource=resource_uid, txid=txid
-        )
+        return INDEXING_KEY.format(kb=kb, shard=logical_shard, resource=resource_uid, txid=txid)
 
     async def indexing(
         self,
@@ -246,9 +238,7 @@ class Storage(abc.ABC, metaclass=abc.ABCMeta):
                     txid=payload.reindex_id,
                 )
             else:
-                key = OLD_INDEXING_KEY.format(
-                    node=payload.node, shard=payload.shard, txid=payload.txid
-                )
+                key = OLD_INDEXING_KEY.format(node=payload.node, shard=payload.shard, txid=payload.txid)
 
         bytes_buffer = await self.downloadbytes(self.indexing_bucket, key)
         if bytes_buffer.getbuffer().nbytes == 0:
@@ -286,17 +276,12 @@ class Storage(abc.ABC, metaclass=abc.ABCMeta):
         # The cloudfile is valid for our environment
         if file.uri == "":
             return False
-        elif (
-            file.source == self.source
-            and self.get_bucket_name(kbid) == file.bucket_name
-        ):
+        elif file.source == self.source and self.get_bucket_name(kbid) == file.bucket_name:
             return False
         else:
             return True
 
-    async def normalize_binary(
-        self, file: CloudFile, destination: StorageField
-    ):  # pragma: no cover
+    async def normalize_binary(self, file: CloudFile, destination: StorageField):  # pragma: no cover
         if file.source == self.source and file.uri != destination.key:
             # This MAY BE the case for NucliaDB hosted deployment (Nuclia's cloud deployment):
             # The data has been pushed to the bucket but with a different key.
@@ -346,14 +331,10 @@ class Storage(abc.ABC, metaclass=abc.ABCMeta):
         self, kbid: str, uuid: str, field: str, ident: str, count: int
     ) -> StorageField:
         bucket = self.get_bucket_name(kbid)
-        key = KB_CONVERSATION_FIELD.format(
-            kbid=kbid, uuid=uuid, field=field, ident=ident, count=count
-        )
+        key = KB_CONVERSATION_FIELD.format(kbid=kbid, uuid=uuid, field=field, ident=ident, count=count)
         return self.field_klass(storage=self, bucket=bucket, fullkey=key)
 
-    def layout_field(
-        self, kbid: str, uuid: str, field: str, ident: str
-    ) -> StorageField:
+    def layout_field(self, kbid: str, uuid: str, field: str, ident: str) -> StorageField:
         bucket = self.get_bucket_name(kbid)
         key = KB_LAYOUT_FIELD.format(kbid=kbid, uuid=uuid, field=field, ident=ident)
         return self.field_klass(storage=self, bucket=bucket, fullkey=key)
@@ -368,9 +349,7 @@ class Storage(abc.ABC, metaclass=abc.ABCMeta):
         # Its a file field value
         bucket = self.get_bucket_name(kbid)
         key = KB_RESOURCE_FIELD.format(kbid=kbid, uuid=uuid, field=field)
-        return self.field_klass(
-            storage=self, bucket=bucket, fullkey=key, field=old_field
-        )
+        return self.field_klass(storage=self, bucket=bucket, fullkey=key, field=old_field)
 
     def file_extracted(
         self, kbid: str, uuid: str, field_type: str, field: str, key: str
@@ -452,9 +431,7 @@ class Storage(abc.ABC, metaclass=abc.ABCMeta):
         key: str,
         range: Optional[Range] = None,
     ):
-        destination: StorageField = self.field_klass(
-            storage=self, bucket=bucket, fullkey=key
-        )
+        destination: StorageField = self.field_klass(storage=self, bucket=bucket, fullkey=key)
         try:
             async for data in destination.iter_data(range=range):
                 yield data
@@ -536,21 +513,15 @@ class Storage(abc.ABC, metaclass=abc.ABCMeta):
     async def finalize(self) -> None: ...
 
     @abc.abstractmethod
-    async def iterate_objects(
-        self, bucket: str, prefix: str
-    ) -> AsyncGenerator[ObjectInfo, None]:
+    async def iterate_objects(self, bucket: str, prefix: str) -> AsyncGenerator[ObjectInfo, None]:
         raise NotImplementedError()
         yield ObjectInfo(name="")
 
     async def copy(self, file: CloudFile, destination: StorageField) -> None:
-        await destination.copy(
-            file.uri, destination.key, file.bucket_name, destination.bucket
-        )
+        await destination.copy(file.uri, destination.key, file.bucket_name, destination.bucket)
 
     async def move(self, file: CloudFile, destination: StorageField) -> None:
-        await destination.move(
-            file.uri, destination.key, file.bucket_name, destination.bucket
-        )
+        await destination.move(file.uri, destination.key, file.bucket_name, destination.bucket)
 
     @abc.abstractmethod
     async def create_kb(self, kbid: str) -> bool: ...

nucliadb_utils/tests/asyncbenchmark.py

@@ -108,9 +108,7 @@ class AsyncBenchmarkFixture(object):  # pragma: no cover
             )
         return timer_precision
 
-    async def _make_runner(
-        self, function_to_benchmark: Callable[..., Awaitable[T]], args, kwargs
-    ):
+    async def _make_runner(self, function_to_benchmark: Callable[..., Awaitable[T]], args, kwargs):
         async def runner(loops_range, timer=self._timer):
             gc_enabled = gc.isenabled()
             if self._disable_gc:
@@ -162,8 +160,7 @@ class AsyncBenchmarkFixture(object):  # pragma: no cover
         if self._mode:
             self.has_error = True
             raise FixtureAlreadyUsed(
-                "Fixture can only be used once. Previously it was used in %s mode."
-                % self._mode
+                "Fixture can only be used once. Previously it was used in %s mode." % self._mode
             )
         try:
             self._mode = "benchmark(...)"
@@ -199,8 +196,7 @@ class AsyncBenchmarkFixture(object):  # pragma: no cover
             if self._warmup:
                 warmup_rounds = min(rounds, max(1, int(self._warmup / iterations)))
                 self._logger.debug(
-                    "  Warmup %s rounds x %s iterations ..."
-                    % (warmup_rounds, iterations)
+                    "  Warmup %s rounds x %s iterations ..." % (warmup_rounds, iterations)
                 )
                 for _ in range(warmup_rounds):
                     await runner(loops_range)
@@ -251,10 +247,7 @@ class AsyncBenchmarkFixture(object):  # pragma: no cover
                 warmup_start = time.time()
                 warmup_iterations = 0
                 warmup_rounds = 0
-                while (
-                    time.time() - warmup_start < self._max_time
-                    and warmup_iterations < self._warmup
-                ):
+                while time.time() - warmup_start < self._max_time and warmup_iterations < self._warmup:
                     duration = min(duration, await runner(loops_range))
                     warmup_rounds += 1
                     warmup_iterations += loops

nucliadb_utils/tests/gcs.py

@@ -61,9 +61,7 @@ class GCS(BaseImage):
 
     def check(self):
         try:
-            response = requests.get(
-                f"http://{self.host}:{self.get_port()}/storage/v1/b"
-            )
+            response = requests.get(f"http://{self.host}:{self.get_port()}/storage/v1/b")
             return response.status_code == 200
         except Exception:  # pragma: no cover
             return False

nucliadb_utils/tests/nats.py

@@ -124,9 +124,7 @@ class Gnatsd(object):
         if self.debug:
             self.proc = subprocess.Popen(cmd)
         else:
-            self.proc = subprocess.Popen(
-                cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-            )
+            self.proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
         if self.debug:
             if self.proc is None:
@@ -135,20 +133,14 @@ class Gnatsd(object):
                     % self.port
                 )
             else:
-                print(
-                    "[\033[0;33mDEBUG\033[0;0m] Server listening on port %d started."
-                    % self.port
-                )
+                print("[\033[0;33mDEBUG\033[0;0m] Server listening on port %d started." % self.port)
         return self.proc
 
     def stop(self):
         if self.folder is not None:
             self.folder.cleanup()
         if self.debug:
-            print(
-                "[\033[0;33mDEBUG\033[0;0m] Server listening on %d will stop."
-                % self.port
-            )
+            print("[\033[0;33mDEBUG\033[0;0m] Server listening on %d will stop." % self.port)
 
         if self.debug:
             if self.proc is None:
@@ -168,10 +160,7 @@ class Gnatsd(object):
             os.kill(self.proc.pid, signal.SIGKILL)
             self.proc.wait()
             if self.debug:
-                print(
-                    "[\033[0;33mDEBUG\033[0;0m] Server listening on %d was stopped."
-                    % self.port
-                )
+                print("[\033[0;33mDEBUG\033[0;0m] Server listening on %d was stopped." % self.port)
 
 
 class NatsServer(Gnatsd):  # pragma: no cover

nucliadb_utils/transaction.py

@@ -26,13 +26,13 @@ from typing import Any, Optional, Union
 import nats
 from nats.aio.client import Client
 from nats.js.client import JetStreamContext
+
 from nucliadb_protos.writer_pb2 import (
     BrokerMessage,
     BrokerMessageBlobReference,
     Notification,
     OpStatusWriter,
 )
-
 from nucliadb_telemetry.jetstream import JetStreamContextTelemetry
 from nucliadb_utils import const, logger
 from nucliadb_utils.cache.pubsub import PubSubDriver
@@ -180,9 +180,7 @@ class TransactionUtility:
         writer: Union[BrokerMessage, BrokerMessageBlobReference],
         partition: int,
         wait: bool = False,
-        target_subject: Optional[
-            str
-        ] = None,  # allow customizing where to send the message
+        target_subject: Optional[str] = None,  # allow customizing where to send the message
         headers: Optional[dict[str, str]] = None,
     ) -> int:
         headers = headers or {}
@@ -192,24 +190,18 @@ class TransactionUtility:
         request_id = uuid.uuid4().hex
 
         if wait:
-            waiting_event = await self.wait_for_commited(
-                writer.kbid, waiting_for, request_id=request_id
-            )
+            waiting_event = await self.wait_for_commited(writer.kbid, waiting_for, request_id=request_id)
 
         if target_subject is None:
             target_subject = const.Streams.INGEST.subject.format(partition=partition)
 
-        res = await self.js.publish(
-            target_subject, writer.SerializeToString(), headers=headers
-        )
+        res = await self.js.publish(target_subject, writer.SerializeToString(), headers=headers)
 
         waiting_for.seq = res.seq
 
         if wait and waiting_event is not None:
             try:
-                await asyncio.wait_for(
-                    waiting_event.wait(), timeout=self.commit_timeout
-                )
+                await asyncio.wait_for(waiting_event.wait(), timeout=self.commit_timeout)
             except asyncio.TimeoutError:
                 logger.warning("Took too much to commit")
                 raise TransactionCommitTimeoutError()

nucliadb_utils/utilities.py

@@ -27,7 +27,6 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any, List, Optional, Union, cast
 
 from nucliadb_protos.writer_pb2_grpc import WriterStub
-
 from nucliadb_utils import featureflagging
 from nucliadb_utils.audit.audit import AuditStorage
 from nucliadb_utils.audit.basic import BasicAuditStorage
@@ -150,9 +149,7 @@ async def get_storage(
         await localutil.initialize()
         logger.info("Configuring Local Storage")
     else:
-        raise ConfigurationError(
-            "Invalid storage settings, please configure FILE_BACKEND"
-        )
+        raise ConfigurationError("Invalid storage settings, please configure FILE_BACKEND")
 
     return MAIN[Utility.STORAGE]
 
@@ -322,9 +319,7 @@ async def start_audit_utility(service: str):
             seed=audit_settings.audit_hash_seed,
             service=service,
         )
-        logger.info(
-            f"Configuring stream audit log {audit_settings.audit_jetstream_target}"
-        )
+        logger.info(f"Configuring stream audit log {audit_settings.audit_jetstream_target}")
     else:
         raise ConfigurationError("Invalid audit driver")
     await audit_utility.initialize()
@@ -390,13 +385,9 @@ def has_feature(
         context = {}
     if headers is not None:
         if X_USER_HEADER in headers:
-            context["user_id_md5"] = hashlib.md5(
-                headers[X_USER_HEADER].encode("utf-8")
-            ).hexdigest()
+            context["user_id_md5"] = hashlib.md5(headers[X_USER_HEADER].encode("utf-8")).hexdigest()
         if X_ACCOUNT_HEADER in headers:
-            context["account_id_md5"] = hashlib.md5(
-                headers[X_ACCOUNT_HEADER].encode()
-            ).hexdigest()
+            context["account_id_md5"] = hashlib.md5(headers[X_ACCOUNT_HEADER].encode()).hexdigest()
         if X_ACCOUNT_TYPE_HEADER in headers:
             context["account_type"] = headers[X_ACCOUNT_TYPE_HEADER]
     return get_feature_flags().enabled(name, default=default, context=context)

{nucliadb_utils-4.0.3.post586.dist-info → nucliadb_utils-4.0.3.post589.dist-info}/METADATA

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

{nucliadb_utils-4.0.3.post586.dist-info → nucliadb_utils-4.0.3.post589.dist-info}/RECORD

@@ -1,35 +1,35 @@
 nucliadb_utils/__init__.py,sha256=EvBCH1iTODe-AgXm48aj4kVUt_Std3PeL8QnwimR5wI,895
-nucliadb_utils/asyncio_utils.py,sha256=9A0xwlw9E4HYAxiPtLlOzurqiTlCWNqvXrpDl1q7szE,2894
-nucliadb_utils/authentication.py,sha256=HTj6kFFrfdN4-DW_MNqldAPqNPdPwGHnSWl-SigiMvk,6071
+nucliadb_utils/asyncio_utils.py,sha256=h8Y-xpcFFRgNzaiIW0eidz7griAQa7ggbNk34-tAt2c,2888
+nucliadb_utils/authentication.py,sha256=N__d2Ez3JHJv5asYK5TgUcIkKqcAC8ZTLlnfLhfSneM,5837
 nucliadb_utils/const.py,sha256=V9SWXB_Nfy0qqgPkQcEYN_zj90WkOpLubeixRKUprfM,2391
-nucliadb_utils/debug.py,sha256=saSfh_CDQoQl-35KCyqef5hdB_OVdrIEnlmWnZU18vg,2470
+nucliadb_utils/debug.py,sha256=Q56Nx9Dp7V2ae3CU2H0ztaZcHTJXdlflPLKLeOPZ170,2436
 nucliadb_utils/exceptions.py,sha256=y_3wk77WLVUtdo-5FtbBsdSkCtK_DsJkdWb5BoPn3qo,1094
-nucliadb_utils/featureflagging.py,sha256=M94p2qQROCmeMX_N3PPvzAR3iaNBGvjwdE1-aAAWp1k,2740
-nucliadb_utils/grpc.py,sha256=USXwPRuCJiSyLf0JW4isIKZne6od8gM_GGLWaHHjknk,3336
-nucliadb_utils/helpers.py,sha256=fOL6eImdvKO3NV39ymmo2UOCT-GAK1dfXKoMKdzdmFo,1599
-nucliadb_utils/indexing.py,sha256=06acsB4zHl7rhnzWr70QqXTX-tTRIZGFZn9HRTS_Ozg,3446
-nucliadb_utils/nats.py,sha256=7hRKMflwxK-p_L0KFO5jibOGhzSw2F24mKvPG-A_iN8,8224
+nucliadb_utils/featureflagging.py,sha256=pgqqO4Kbqj4aCuTRbfDK4nXWvWgRUM4GPZu0da-8DG8,2726
+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/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
-nucliadb_utils/run.py,sha256=bKMfsPEK6WdWfiPyWPUxCqcLo4tq6eOwyaf910TOwBk,1713
-nucliadb_utils/settings.py,sha256=WVL2u_jCkm7Uf6a2njOZetHM_nU0hwDVhLqfH0k5Yi4,7238
-nucliadb_utils/signals.py,sha256=5r53hZvZmwgKdri5jHEjuHmiaq5TyusUUvjoq2uliIc,2704
+nucliadb_utils/run.py,sha256=HpAIM8xbR7UpVC2_7xOjB4fYbUVykyPP6yHrv2RD3DI,1707
+nucliadb_utils/settings.py,sha256=fI3AOn30tNvYS_PqoKilVhJN4OppPAGCM6-OUUitO2s,7192
+nucliadb_utils/signals.py,sha256=JRNv2y9zLtBjOANBf7krGfDGfOc9qcoXZ6N1nKWS2FE,2674
 nucliadb_utils/store.py,sha256=kQ35HemE0v4_Qg6xVqNIJi8vSFAYQtwI3rDtMsNy62Y,890
-nucliadb_utils/transaction.py,sha256=CQpsuF-E2omh4gGMxXCn0dv7vL9ctxooWpSgWGbGfBA,7212
-nucliadb_utils/utilities.py,sha256=yaZGGsaRLKuHbSM-dI_9LDKM-2N02804TWGeo13zOLg,13708
+nucliadb_utils/transaction.py,sha256=ym9hmPAoIt8xgxjd8JHG14_PelYTqhUOVfUAq_ghJDM,7100
+nucliadb_utils/utilities.py,sha256=E7W9TzvbyJ7_Yenho9CT059E_g4JQOCS02HrGurwNqs,13603
 nucliadb_utils/audit/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
-nucliadb_utils/audit/audit.py,sha256=ruSdsw5TpOHLzgCDhOjzF_nVwY-2fODuiiUVwgJprLc,2818
-nucliadb_utils/audit/basic.py,sha256=8_QCqF5PGnIYTc5voJsXpPGZaRaLPshShmrTBipmS-s,3414
-nucliadb_utils/audit/stream.py,sha256=W207A1MkLc9RYTj-tSoZHRfxVUephEFqvX0StUzd_FI,12026
+nucliadb_utils/audit/audit.py,sha256=dn5ZnCVQUlCcvdjzaORghbrjk9QgVGrtkfIftq30Bp8,2819
+nucliadb_utils/audit/basic.py,sha256=NViey6mKbCXqRTLDBX2xNTcCg9I-2e4oB2xkekuhDvM,3392
+nucliadb_utils/audit/stream.py,sha256=CSNFrwCT_IeHFStx4q4ImgOQ7v0WzJr4YG6QRzE7YlQ,11952
 nucliadb_utils/cache/__init__.py,sha256=itSI7dtTwFP55YMX4iK7JzdMHS5CQVUiB1XzQu4UBh8,833
 nucliadb_utils/cache/exceptions.py,sha256=Zu-O_-0-yctOEgoDGI92gPzWfBMRrpiAyESA62ld6MA,975
-nucliadb_utils/cache/nats.py,sha256=4EnzvYK39ViH4Tp90NT0MltJ12E3ryWefAe6xra7Lmc,7073
+nucliadb_utils/cache/nats.py,sha256=-AjCfkFgKVdJUlGR0hT9JDSNkPVFg4S6w9eW-ZIcXPM,7037
 nucliadb_utils/cache/pubsub.py,sha256=l8i_RwRf7OPzfmPy-gyn66xgYFs5aHidCIjEaU9VOHE,1654
 nucliadb_utils/cache/settings.py,sha256=WVeHOE6Re5i4k2hUHdFKfkoL4n83v_Z6UPBK6GHYb8g,1059
 nucliadb_utils/fastapi/__init__.py,sha256=itSI7dtTwFP55YMX4iK7JzdMHS5CQVUiB1XzQu4UBh8,833
 nucliadb_utils/fastapi/openapi.py,sha256=b0pLuri0QuzQd0elDyOVXM42YYmES_cmT-jEfsQ1G6Y,1737
 nucliadb_utils/fastapi/run.py,sha256=n6vOX64QqF1I5n4UlKnpm_ZJ24rmwfRGi-J9YMGpZzA,3631
-nucliadb_utils/fastapi/versioning.py,sha256=uOVdKl8GzBt8L1YnU5GjBsNeDdFV2yrjjYFEGqUXRgQ,3774
+nucliadb_utils/fastapi/versioning.py,sha256=pwiwuesJW1jElUUI3pI5kcxkigfGBvI64IL6QCBEWS8,3805
 nucliadb_utils/nuclia_usage/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb_utils/nuclia_usage/protos/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb_utils/nuclia_usage/protos/kb_usage_pb2.py,sha256=7jBWh5aFkNOU6rF_rdp-twZONgrJe3ztJdqKvRWcMM4,5934
@@ -39,23 +39,23 @@ nucliadb_utils/nuclia_usage/protos/kb_usage_pb2_grpc.pyi,sha256=6RIsZ2934iodEckf
 nucliadb_utils/nuclia_usage/utils/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb_utils/nuclia_usage/utils/kb_usage_report.py,sha256=E1eUSFXBVNzQP9Q2rWj9y3koCO5S7iKwckny_AoLKuk,3870
 nucliadb_utils/storages/__init__.py,sha256=5Qc8AUWiJv9_JbGCBpAn88AIJhwDlm0OPQpg2ZdRL4U,872
-nucliadb_utils/storages/exceptions.py,sha256=n6aBOyurWMo8mXd1XY6Psgno4VfXJ9TRbxCy67c08-g,2417
-nucliadb_utils/storages/gcs.py,sha256=HZpyyHrEA4ZsoDMVyK5PRc99FGAmvnvsJpWEq7my1ug,27356
-nucliadb_utils/storages/local.py,sha256=nDrmWy1na96AS__hO3TQqsYMHnu0buwnfUGWfxCpWYU,10348
-nucliadb_utils/storages/nuclia.py,sha256=UfvRu92eqG1v-PE-UWH2x8KEJFqDqATMmUGFmEuqSSs,2097
-nucliadb_utils/storages/s3.py,sha256=_nw9ztAQyri1W2gbT06NHacrxbC0MjA7jYu0U06KfiM,19484
+nucliadb_utils/storages/exceptions.py,sha256=BfJcn0-60Ts2gLHRTxQKD0QuR7L4WDJtIdsUp7zhQ0k,2395
+nucliadb_utils/storages/gcs.py,sha256=KQ9puMOE89CPIA8q8DeCs7qOp0YoB5ZctXPws1h7lbA,27006
+nucliadb_utils/storages/local.py,sha256=GAEzvbmLzEeEJhhIWKa-vX2i9B0qdq6mbHMolpa2Q20,10259
+nucliadb_utils/storages/nuclia.py,sha256=vEv94xAT7QM2g80S25QyrOw2pzvP2BAX-ADgZLtuCVc,2097
+nucliadb_utils/storages/s3.py,sha256=ABzS9X3fj7SUq-3cLvnKEClngb8hcPyKNSfxubMpyCo,19256
 nucliadb_utils/storages/settings.py,sha256=ugCPy1zxBOmA2KosT-4tsjpvP002kg5iQyi42yCGCJA,1285
-nucliadb_utils/storages/storage.py,sha256=KJ5VDYoZuRmiCFwfLj__tDOHIJWyQAMi-sOXCMoJv9w,20831
+nucliadb_utils/storages/storage.py,sha256=SWeQv6136ruj7TvCPQR6WkG458IDEz2fzQQjkDRRReQ,20533
 nucliadb_utils/tests/__init__.py,sha256=Oo9CAE7B0eW5VHn8sHd6o30SQzOWUhktLPRXdlDOleA,1456
-nucliadb_utils/tests/asyncbenchmark.py,sha256=6VP_G0BGNpmFGa4pwmsnGxYhj-h_fABBbX_RVZTEfJo,10697
+nucliadb_utils/tests/asyncbenchmark.py,sha256=x4be2IwCawle9zWgMOJkmwoUwk5p1tv7cLQGmybkEOg,10587
 nucliadb_utils/tests/fixtures.py,sha256=j58fTvoWZClC52LX7QOvLXX9DS5QbytSnRp0F4nGzN8,1671
-nucliadb_utils/tests/gcs.py,sha256=DR6K7s5cH3TAokHbyaUFVNnylKZf3GfiefdEv9s2rpo,3066
+nucliadb_utils/tests/gcs.py,sha256=Ii8BCHUAAxFIzX67pKTRFRgbqv3FJ6DrPAdAx2Xod1Y,3036
 nucliadb_utils/tests/indexing.py,sha256=YW2QhkhO9Q_8A4kKWJaWSvXvyQ_AiAwY1VylcfVQFxk,1513
 nucliadb_utils/tests/local.py,sha256=c3gZJJWmvOftruJkIQIwB3q_hh3uxEhqGIAVWim1Bbk,1343
-nucliadb_utils/tests/nats.py,sha256=0Ow8jRUHIcOJfh-h1lWxA4h52OFgGVoWqRClR4Y1YHo,7735
+nucliadb_utils/tests/nats.py,sha256=Tosonm9A9cusImyji80G4pgdXEHNVPaCLT5TbFK_ra0,7543
 nucliadb_utils/tests/s3.py,sha256=YB8QqDaBXxyhHonEHmeBbRRDmvB7sTOaKBSi8KBGokg,2330
-nucliadb_utils-4.0.3.post586.dist-info/METADATA,sha256=WMmjIxM66s_3YEq4RcknbxUh7nydTrxjhyPAfgzjLFY,2030
-nucliadb_utils-4.0.3.post586.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-nucliadb_utils-4.0.3.post586.dist-info/top_level.txt,sha256=fE3vJtALTfgh7bcAWcNhcfXkNPp_eVVpbKK-2IYua3E,15
-nucliadb_utils-4.0.3.post586.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-nucliadb_utils-4.0.3.post586.dist-info/RECORD,,
+nucliadb_utils-4.0.3.post589.dist-info/METADATA,sha256=YHbtxvU4f1pk0u4KI5CoM1J2bJxAFD9nPOZ9jI5wc8c,2030
+nucliadb_utils-4.0.3.post589.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+nucliadb_utils-4.0.3.post589.dist-info/top_level.txt,sha256=fE3vJtALTfgh7bcAWcNhcfXkNPp_eVVpbKK-2IYua3E,15
+nucliadb_utils-4.0.3.post589.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+nucliadb_utils-4.0.3.post589.dist-info/RECORD,,