nucliadb 6.9.1.post5192__py3-none-any.whl → 6.10.0.post5705__py3-none-any.whl

nucliadb/writer/api/v1/upload.py

@@ -18,12 +18,11 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import base64
-import pickle
 import uuid
 from datetime import datetime
 from hashlib import md5
 from io import BytesIO
-from typing import Annotated, Optional
+from typing import Annotated
 
 from fastapi import HTTPException
 from fastapi.requests import Request
@@ -123,17 +122,17 @@ TUS_HEADERS = {
 def tus_options(
     request: Request,
     kbid: str,
-    rid: Optional[str] = None,
-    rslug: Optional[str] = None,
-    upload_id: Optional[str] = None,
-    field: Optional[str] = None,
+    rid: str | None = None,
+    rslug: str | None = None,
+    upload_id: str | None = None,
+    field: str | None = None,
 ) -> Response:
     return _tus_options()
 
 
 def _tus_options() -> Response:
     """
-    Gather information about the Server’s current configuration such as enabled extensions, version...
+    Gather information about the Server's current configuration such as enabled extensions, version...
     """
     resp = Response(headers=TUS_HEADERS, status_code=204)
     return resp
@@ -152,9 +151,9 @@ async def tus_post_rslug_prefix(
     kbid: str,
     rslug: str,
     field: FieldIdString,
-    item: Optional[CreateResourcePayload] = None,
-    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
-    x_split_strategy: Annotated[Optional[str], X_SPLIT_STRATEGY] = None,
+    item: CreateResourcePayload | None = None,
+    x_extract_strategy: Annotated[str | None, X_EXTRACT_STRATEGY] = None,
+    x_split_strategy: Annotated[str | None, X_SPLIT_STRATEGY] = None,
 ) -> Response:
     rid = await get_rid_from_slug_or_raise_error(kbid, rslug)
     return await _tus_post(
@@ -181,9 +180,9 @@ async def tus_post_rid_prefix(
     kbid: str,
     path_rid: str,
     field: FieldIdString,
-    item: Optional[CreateResourcePayload] = None,
-    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
-    x_split_strategy: Annotated[Optional[str], X_SPLIT_STRATEGY] = None,
+    item: CreateResourcePayload | None = None,
+    x_extract_strategy: Annotated[str | None, X_EXTRACT_STRATEGY] = None,
+    x_split_strategy: Annotated[str | None, X_SPLIT_STRATEGY] = None,
 ) -> Response:
     return await _tus_post(
         request,
@@ -207,9 +206,9 @@ async def tus_post_rid_prefix(
 async def tus_post(
     request: Request,
     kbid: str,
-    item: Optional[CreateResourcePayload] = None,
-    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
-    x_split_strategy: Annotated[Optional[str], X_SPLIT_STRATEGY] = None,
+    item: CreateResourcePayload | None = None,
+    x_extract_strategy: Annotated[str | None, X_EXTRACT_STRATEGY] = None,
+    x_split_strategy: Annotated[str | None, X_SPLIT_STRATEGY] = None,
 ) -> Response:
     return await _tus_post(
         request, kbid, item, extract_strategy=x_extract_strategy, split_strategy=x_split_strategy
@@ -220,11 +219,11 @@ async def tus_post(
 async def _tus_post(
     request: Request,
     kbid: str,
-    item: Optional[CreateResourcePayload] = None,
-    path_rid: Optional[str] = None,
-    field_id: Optional[str] = None,
-    extract_strategy: Optional[str] = None,
-    split_strategy: Optional[str] = None,
+    item: CreateResourcePayload | None = None,
+    path_rid: str | None = None,
+    field_id: str | None = None,
+    extract_strategy: str | None = None,
+    split_strategy: str | None = None,
 ) -> Response:
     """
     An empty POST request is used to create a new upload resource.
@@ -265,7 +264,7 @@ async def _tus_post(
         try:
             metadata = parse_tus_metadata(request.headers["upload-metadata"])
         except InvalidTUSMetadata as exc:
-            raise HTTPBadRequest(detail=f"Upload-Metadata header contains errors: {str(exc)}")
+            raise HTTPBadRequest(detail=f"Upload-Metadata header contains errors: {exc!s}")
     else:
         metadata = {}
 
@@ -309,8 +308,8 @@ async def _tus_post(
     metadata["implies_resource_creation"] = implies_resource_creation
 
     creation_payload = None
-    if implies_resource_creation:
-        creation_payload = base64.b64encode(pickle.dumps(item)).decode()
+    if implies_resource_creation and item is not None:
+        creation_payload = item.model_dump()
 
     await dm.load(upload_id)
     await dm.start(request)
@@ -339,7 +338,7 @@ async def _tus_post(
     return Response(
         status_code=201,
         headers={
-            "Location": location,  # noqa
+            "Location": location,
             "Tus-Resumable": "1.0.0",
             "Access-Control-Expose-Headers": "Location,Tus-Resumable",
         },
@@ -485,8 +484,8 @@ async def tus_patch(
     request: Request,
     kbid: str,
     upload_id: str,
-    rid: Optional[str] = None,
-    field: Optional[str] = None,
+    rid: str | None = None,
+    field: str | None = None,
 ):
     try:
         return await _tus_patch(
@@ -508,8 +507,8 @@ async def _tus_patch(
     request: Request,
     kbid: str,
     upload_id: str,
-    rid: Optional[str] = None,
-    field: Optional[str] = None,
+    rid: str | None = None,
+    field: str | None = None,
 ) -> Response:
     """
     Upload all bytes in the requests and append them in the specified offset
@@ -545,6 +544,13 @@ async def _tus_patch(
         )
 
     storage_manager = get_storage_manager()
+
+    # We consider this to be the last chunk if we have the size stored and we've reached it
+    current_chunk_size = int(request.headers["content-length"])
+    upload_finished = dm.get("size") is not None and dm.offset + current_chunk_size >= dm.get("size")
+    if not upload_finished:
+        validate_intermediate_tus_chunk(current_chunk_size, storage_manager)
+
     read_bytes = await storage_manager.append(
         dm,
         storage_manager.iterate_body_chunks(request, storage_manager.chunk_size),
@@ -563,8 +569,6 @@ async def _tus_patch(
             ["Upload-Offset", "Tus-Resumable", "Tus-Upload-Finished"]
         ),
     }
-
-    upload_finished = dm.get("size") is not None and dm.offset >= dm.get("size")
     if upload_finished:
         rid = dm.get("rid", rid)
         if rid is None:
@@ -580,9 +584,7 @@ async def _tus_patch(
         item_payload = dm.get("item")
         creation_payload = None
         if item_payload is not None:
-            if isinstance(item_payload, str):
-                item_payload = item_payload.encode()
-            creation_payload = pickle.loads(base64.b64decode(item_payload))
+            creation_payload = CreateResourcePayload.model_validate(item_payload)
 
         content_type = dm.get("metadata", {}).get("content_type")
         if content_type is not None and not content_types.valid(content_type):
@@ -616,7 +618,6 @@ async def _tus_patch(
 
         headers["NDB-Seq"] = f"{seqid}"
     else:
-        validate_intermediate_tus_chunk(read_bytes, storage_manager)
         await dm.save()
 
     return Response(headers=headers)
@@ -643,12 +644,12 @@ async def upload_rslug_prefix(
     kbid: str,
     rslug: str,
     field: FieldIdString,
-    x_filename: Annotated[Optional[str], X_FILENAME] = None,
-    x_password: Annotated[Optional[str], X_PASSWORD] = None,
-    x_language: Annotated[Optional[str], X_LANGUAGE] = None,
-    x_md5: Annotated[Optional[str], X_MD5] = None,
-    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
-    x_split_strategy: Annotated[Optional[str], X_SPLIT_STRATEGY] = None,
+    x_filename: Annotated[str | None, X_FILENAME] = None,
+    x_password: Annotated[str | None, X_PASSWORD] = None,
+    x_language: Annotated[str | None, X_LANGUAGE] = None,
+    x_md5: Annotated[str | None, X_MD5] = None,
+    x_extract_strategy: Annotated[str | None, X_EXTRACT_STRATEGY] = None,
+    x_split_strategy: Annotated[str | None, X_SPLIT_STRATEGY] = None,
 ) -> ResourceFileUploaded:
     rid = await get_rid_from_slug_or_raise_error(kbid, rslug)
     return await _upload(
@@ -679,12 +680,12 @@ async def upload_rid_prefix(
     kbid: str,
     path_rid: str,
     field: FieldIdString,
-    x_filename: Annotated[Optional[str], X_FILENAME] = None,
-    x_password: Annotated[Optional[str], X_PASSWORD] = None,
-    x_language: Annotated[Optional[str], X_LANGUAGE] = None,
-    x_md5: Annotated[Optional[str], X_MD5] = None,
-    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
-    x_split_strategy: Annotated[Optional[str], X_SPLIT_STRATEGY] = None,
+    x_filename: Annotated[str | None, X_FILENAME] = None,
+    x_password: Annotated[str | None, X_PASSWORD] = None,
+    x_language: Annotated[str | None, X_LANGUAGE] = None,
+    x_md5: Annotated[str | None, X_MD5] = None,
+    x_extract_strategy: Annotated[str | None, X_EXTRACT_STRATEGY] = None,
+    x_split_strategy: Annotated[str | None, X_SPLIT_STRATEGY] = None,
 ) -> ResourceFileUploaded:
     return await _upload(
         request,
@@ -712,12 +713,12 @@ async def upload_rid_prefix(
 async def upload(
     request: StarletteRequest,
     kbid: str,
-    x_filename: Annotated[Optional[str], X_FILENAME] = None,
-    x_password: Annotated[Optional[str], X_PASSWORD] = None,
-    x_language: Annotated[Optional[str], X_LANGUAGE] = None,
-    x_md5: Annotated[Optional[str], X_MD5] = None,
-    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
-    x_split_strategy: Annotated[Optional[str], X_SPLIT_STRATEGY] = None,
+    x_filename: Annotated[str | None, X_FILENAME] = None,
+    x_password: Annotated[str | None, X_PASSWORD] = None,
+    x_language: Annotated[str | None, X_LANGUAGE] = None,
+    x_md5: Annotated[str | None, X_MD5] = None,
+    x_extract_strategy: Annotated[str | None, X_EXTRACT_STRATEGY] = None,
+    x_split_strategy: Annotated[str | None, X_SPLIT_STRATEGY] = None,
 ) -> ResourceFileUploaded:
     return await _upload(
         request,
@@ -735,14 +736,14 @@ async def upload(
 async def _upload(
     request: StarletteRequest,
     kbid: str,
-    path_rid: Optional[str] = None,
-    field: Optional[str] = None,
-    x_filename: Optional[str] = None,
-    x_password: Optional[str] = None,
-    x_language: Optional[str] = None,
-    x_md5: Optional[str] = None,
-    x_extract_strategy: Optional[str] = None,
-    x_split_strategy: Optional[str] = None,
+    path_rid: str | None = None,
+    field: str | None = None,
+    x_filename: str | None = None,
+    x_password: str | None = None,
+    x_language: str | None = None,
+    x_md5: str | None = None,
+    x_extract_strategy: str | None = None,
+    x_split_strategy: str | None = None,
 ) -> ResourceFileUploaded:
     if path_rid is not None:
         await validate_rid_exists_or_raise_error(kbid, path_rid)
@@ -847,9 +848,9 @@ async def _upload(
 
 async def validate_field_upload(
     kbid: str,
-    rid: Optional[str] = None,
-    field: Optional[str] = None,
-    md5: Optional[str] = None,
+    rid: str | None = None,
+    field: str | None = None,
+    md5: str | None = None,
 ):
     """Validate field upload and return blob storage path, rid and field id.
 
@@ -892,14 +893,14 @@ async def store_file_on_nuclia_db(
     field: str,
     content_type: str = "application/octet-stream",
     override_resource_title: bool = False,
-    filename: Optional[str] = None,
-    password: Optional[str] = None,
-    language: Optional[str] = None,
-    md5: Optional[str] = None,
-    item: Optional[CreateResourcePayload] = None,
-    extract_strategy: Optional[str] = None,
-    split_strategy: Optional[str] = None,
-) -> Optional[int]:
+    filename: str | None = None,
+    password: str | None = None,
+    language: str | None = None,
+    md5: str | None = None,
+    item: CreateResourcePayload | None = None,
+    extract_strategy: str | None = None,
+    split_strategy: str | None = None,
+) -> int | None:
     # File is on NucliaDB Storage at path
     partitioning = get_partitioning()
     processing = get_processing()

nucliadb/writer/app.py

@@ -26,6 +26,7 @@ from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.requests import ClientDisconnect
 from starlette.responses import HTMLResponse
 
+from nucliadb.middleware import ClientErrorPayloadLoggerMiddleware
 from nucliadb.writer import API_PREFIX
 from nucliadb.writer.api.v1.router import api as api_v1
 from nucliadb.writer.lifecycle import lifespan
@@ -41,14 +42,18 @@ from nucliadb_utils.settings import running_settings
 
 middleware = []
 
-middleware.extend([Middleware(AuthenticationMiddleware, backend=NucliaCloudAuthenticationBackend())])
+middleware.extend(
+    [
+        Middleware(AuthenticationMiddleware, backend=NucliaCloudAuthenticationBackend()),
+        Middleware(ClientErrorPayloadLoggerMiddleware),
+    ]
+)
 
 
 errors.setup_error_handling(importlib.metadata.distribution("nucliadb").version)
 
 fastapi_settings = dict(
     debug=running_settings.debug,
-    middleware=middleware,
     lifespan=lifespan,
     exception_handlers={
         Exception: global_exception_handler,
@@ -70,6 +75,7 @@ def create_application() -> FastAPI:
         prefix_format=f"/{API_PREFIX}/v{{major}}",
         default_version=(1, 0),
         enable_latest=False,
+        middleware=middleware,
         kwargs=fastapi_settings,
     )
 

nucliadb/writer/resource/basic.py

@@ -18,7 +18,6 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 from datetime import datetime
-from typing import Optional, Union
 
 from fastapi import HTTPException
 
@@ -122,18 +121,16 @@ def parse_basic_modify(bm: BrokerMessage, item: ComingResourcePayload, toprocess
             bm.basic.fieldmetadata.append(userfieldmetadata)
 
     if item.usermetadata is not None:
-        # protobufers repeated fields don't support assignment
-        # will allways be a clean basic
-        bm.basic.usermetadata.classifications.extend(
-            [
-                Classification(
-                    labelset=x.labelset,
-                    label=x.label,
-                    cancelled_by_user=x.cancelled_by_user,
-                )
-                for x in item.usermetadata.classifications
-            ]
-        )
+        classifs = []
+        for classif in item.usermetadata.classifications:
+            classif_pb = Classification(
+                labelset=classif.labelset,
+                label=classif.label,
+                cancelled_by_user=classif.cancelled_by_user,
+            )
+            if classif_pb not in classifs:
+                classifs.append(classif_pb)
+        bm.basic.usermetadata.classifications.extend(classifs)
 
         relation_node_resource = RelationNode(value=bm.uuid, ntype=RelationNode.NodeType.RESOURCE)
         relations = []
@@ -180,7 +177,7 @@ def parse_basic_creation(
     bm: BrokerMessage,
     item: CreateResourcePayload,
     toprocess: PushPayload,
-    kb_config: Optional[KnowledgeBoxConfig],
+    kb_config: KnowledgeBoxConfig | None,
 ):
     bm.basic.created.FromDatetime(datetime.now())
 
@@ -263,7 +260,7 @@ def build_question_answer_annotation_pb(
 
 
 def parse_user_classifications(
-    item: Union[CreateResourcePayload, UpdateResourcePayload],
+    item: CreateResourcePayload | UpdateResourcePayload,
 ) -> list[ClassificationLabel]:
     return (
         [

nucliadb/writer/resource/field.py

@@ -19,7 +19,6 @@
 #
 import dataclasses
 from datetime import datetime
-from typing import Optional, Union
 
 from fastapi import HTTPException
 from google.protobuf.json_format import MessageToDict
@@ -88,7 +87,7 @@ async def extract_file_field(
     resource: ORMResource,
     toprocess: PushPayload,
     resource_classifications: ResourceClassifications,
-    password: Optional[str] = None,
+    password: str | None = None,
 ):
     field_type = resources_pb2.FieldType.FILE
     field = await resource.get_field(field_id, field_type)
@@ -183,7 +182,7 @@ async def extract_fields(resource: ORMResource, toprocess: PushPayload):
 async def parse_fields(
     writer: BrokerMessage,
     toprocess: PushPayload,
-    item: Union[CreateResourcePayload, UpdateResourcePayload],
+    item: CreateResourcePayload | UpdateResourcePayload,
     kbid: str,
     uuid: str,
     x_skip_store: bool,
@@ -555,7 +554,7 @@ async def _conversation_append_checks(
     kbid: str, rid: str, field_id: str, input: models.InputConversationField
 ):
     async with datamanagers.with_ro_transaction() as txn:
-        resource_obj = await datamanagers.resources.get_resource(txn, kbid=kbid, rid=rid)
+        resource_obj = await ORMResource.get(txn, kbid=kbid, rid=rid)
         if resource_obj is None:
             return
         conv: Conversation = await resource_obj.get_field(
@@ -564,7 +563,10 @@ async def _conversation_append_checks(
 
         # Make sure that the max number of messages is not exceeded
         current_message_count = (await conv.get_metadata()).total
-        if len(input.messages) + current_message_count > MAX_CONVERSATION_MESSAGES:
+        if (
+            MAX_CONVERSATION_MESSAGES is not None
+            and (len(input.messages) + current_message_count) > MAX_CONVERSATION_MESSAGES
+        ):
             raise HTTPException(
                 status_code=422,
                 detail=f"Conversation fields cannot have more than {MAX_CONVERSATION_MESSAGES} messages.",

nucliadb/writer/resource/origin.py

@@ -42,6 +42,13 @@ def parse_origin(origin: Origin, origin_payload: InputOrigin):
         origin.metadata.update(origin_payload.metadata)
     if origin_payload.path:
         origin.path = origin_payload.path
+    if origin_payload.sync_metadata is not None:
+        origin.sync_metadata.CopyFrom(
+            resources_pb2.SyncMetadata(
+                file_id=origin_payload.sync_metadata.file_id,
+                auth_provider=origin_payload.sync_metadata.auth_provider,
+            )
+        )
     origin.source = Origin.Source.API
 
 

nucliadb/writer/settings.py

@@ -17,15 +17,14 @@
 # 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 Optional
 
 from pydantic_settings import BaseSettings
 
 
 class Settings(BaseSettings):
     dm_enabled: bool = True
-    dm_redis_host: Optional[str] = None
-    dm_redis_port: Optional[int] = None
+    dm_redis_host: str | None = None
+    dm_redis_port: int | None = None
 
 
 settings = Settings()

nucliadb/writer/tus/__init__.py

@@ -18,7 +18,6 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 from dataclasses import dataclass
-from typing import Optional
 
 from nucliadb.writer.settings import settings as writer_settings
 from nucliadb.writer.tus.dm import FileDataManager, RedisFileDataManagerFactory
@@ -37,8 +36,8 @@ class TusStorageDriver:
     manager: FileStorageManager
 
 
-DRIVER: Optional[TusStorageDriver] = None
-REDIS_FILE_DATA_MANAGER_FACTORY: Optional[RedisFileDataManagerFactory] = None
+DRIVER: TusStorageDriver | None = None
+REDIS_FILE_DATA_MANAGER_FACTORY: RedisFileDataManagerFactory | None = None
 
 
 async def initialize():

nucliadb/writer/tus/azure.py

@@ -19,8 +19,6 @@
 #
 from __future__ import annotations
 
-from typing import Optional
-
 from nucliadb.writer import logger
 from nucliadb.writer.tus.dm import FileDataManager
 from nucliadb.writer.tus.storage import BlobStore, FileStorageManager
@@ -40,7 +38,7 @@ class AzureBlobStore(BlobStore):
             logger.exception("Error closing AzureBlobStore")
         self._object_store = None
 
-    async def initialize(self, account_url: str, connection_string: Optional[str] = None):
+    async def initialize(self, account_url: str, connection_string: str | None = None):
         self.bucket = "nucliadb-{kbid}"
         self.source = CloudFile.Source.AZURE
         self._object_store = AzureObjectStore(account_url, connection_string=connection_string)

nucliadb/writer/tus/dm.py

@@ -18,7 +18,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import time
-from typing import Any, Optional
+from typing import Any
 
 import backoff
 import orjson
@@ -43,7 +43,7 @@ DATA: dict[str, Any] = {}
 
 
 class FileDataManager:
-    _data: Optional[dict[str, Any]] = None
+    _data: dict[str, Any] | None = None
     _loaded = False
     key = None
     _ttl = 60 * 50 * 5  # 5 minutes should be plenty of time between activity
@@ -63,7 +63,7 @@ class FileDataManager:
         if self._data and "last_activity" in self._data:
             # check for another active upload, fail if we're screwing with
             # someone else
-            last_activity: Optional[int] = self._data.get("last_activity")
+            last_activity: int | None = self._data.get("last_activity")
             if last_activity and (time.time() - last_activity) < self._ttl:
                 if request.headers and request.headers.get("tus-override-upload", "0") != "1":
                     raise HTTPPreconditionFailed(

nucliadb/writer/tus/exceptions.py

@@ -17,7 +17,6 @@
 # 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 Optional
 
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
@@ -27,11 +26,11 @@ class InvalidTUSMetadata(Exception):
 
 
 class HTTPException(StarletteHTTPException):
-    _status_code: Optional[int] = None
+    _status_code: int | None = None
 
-    def __init__(self, detail: Optional[str] = None):
+    def __init__(self, detail: str | None = None):
         if self._status_code:
-            super(HTTPException, self).__init__(status_code=self._status_code, detail=detail)
+            super().__init__(status_code=self._status_code, detail=detail)
         else:
             raise AttributeError("Status code not defined")
 

nucliadb/writer/tus/gcs.py

@@ -28,7 +28,6 @@ import tempfile
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 from copy import deepcopy
-from typing import Optional
 from urllib.parse import quote_plus
 
 import aiohttp
@@ -74,11 +73,11 @@ RETRIABLE_EXCEPTIONS = (
 
 
 class GCloudBlobStore(BlobStore):
-    _session: Optional[aiohttp.ClientSession] = None
+    _session: aiohttp.ClientSession | None = None
     loop = None
     upload_url: str
     object_base_url: str
-    json_credentials: Optional[str]
+    json_credentials: str | None
     bucket: str
     location: str
     project: str
@@ -123,7 +122,7 @@ class GCloudBlobStore(BlobStore):
         project: str,
         bucket_labels,
         object_base_url: str,
-        json_credentials: Optional[str],
+        json_credentials: str | None,
     ):
         self.bucket = bucket
         self.source = CloudFile.Source.GCS
@@ -131,7 +130,7 @@ class GCloudBlobStore(BlobStore):
         self.project = project
         self.bucket_labels = bucket_labels
         self.object_base_url = object_base_url + "/storage/v1/b"
-        self.upload_url = object_base_url + "/upload/storage/v1/b/{bucket}/o?uploadType=resumable"  # noqa
+        self.upload_url = object_base_url + "/upload/storage/v1/b/{bucket}/o?uploadType=resumable"
         self.json_credentials = json_credentials
         self._credentials = None
 
@@ -311,7 +310,7 @@ class GCloudFileStorageManager(FileStorageManager):
             },
             data=data,
         ) as call:
-            text = await call.text()  # noqa
+            text = await call.text()
             if call.status not in [200, 201, 308]:
                 raise GoogleCloudException(f"{call.status}: {text}")
             return call

nucliadb/writer/tus/s3.py

@@ -22,7 +22,6 @@ from __future__ import annotations
 import base64
 import uuid
 from contextlib import AsyncExitStack
-from typing import Optional
 
 import aiobotocore  # type: ignore
 import aiohttp
@@ -195,8 +194,8 @@ class S3BlobStore(BlobStore):
         endpoint_url,
         region_name,
         bucket,
-        bucket_tags: Optional[dict[str, str]] = None,
-        kms_key_id: Optional[str] = None,
+        bucket_tags: dict[str, str] | None = None,
+        kms_key_id: str | None = None,
     ):
         self.bucket = bucket
         self.bucket_tags = bucket_tags

nucliadb/writer/tus/storage.py

@@ -19,7 +19,7 @@
 #
 from __future__ import annotations
 
-from typing import AsyncIterator, Optional
+from collections.abc import AsyncIterator
 
 from nucliadb.writer.tus.dm import FileDataManager
 from nucliadb_protos.resources_pb2 import CloudFile
@@ -47,13 +47,13 @@ class BlobStore:
 
 class FileStorageManager:
     chunk_size: int
-    min_upload_size: Optional[int] = None
+    min_upload_size: int | None = None
 
     def __init__(self, storage: BlobStore):
         self.storage = storage
 
     def iter_data(
-        self, uri: str, kbid: str, headers: Optional[dict[str, str]] = None
+        self, uri: str, kbid: str, headers: dict[str, str] | None = None
     ) -> AsyncIterator[bytes]:
         raise NotImplementedError()