nucliadb 4.0.0.post542__py3-none-any.whl → 6.2.1.post2798__py3-none-any.whl

nucliadb/writer/api/v1/upload.py

@@ -18,21 +18,18 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import base64
-import mimetypes
 import pickle
 import uuid
 from datetime import datetime
 from hashlib import md5
 from io import BytesIO
-from typing import Optional
+from typing import Annotated, Optional
 
 from fastapi import HTTPException
 from fastapi.params import Header
 from fastapi.requests import Request
 from fastapi.responses import Response
-from fastapi_versioning import version  # type: ignore
-from nucliadb_protos.resources_pb2 import FieldFile, Metadata
-from nucliadb_protos.writer_pb2 import BrokerMessage
+from fastapi_versioning import version
 from starlette.requests import Request as StarletteRequest
 
 from nucliadb.common import datamanagers
@@ -40,13 +37,15 @@ from nucliadb.ingest.orm.utils import set_title
 from nucliadb.ingest.processing import PushPayload, Source
 from nucliadb.models.responses import HTTPClientError
 from nucliadb.writer import SERVICE_NAME
+from nucliadb.writer.api.v1 import transaction
 from nucliadb.writer.api.v1.resource import (
     get_rid_from_slug_or_raise_error,
     validate_rid_exists_or_raise_error,
 )
+from nucliadb.writer.api.v1.slug import ensure_slug_uniqueness, noop_context_manager
 from nucliadb.writer.back_pressure import maybe_back_pressure
 from nucliadb.writer.resource.audit import parse_audit
-from nucliadb.writer.resource.basic import parse_basic
+from nucliadb.writer.resource.basic import parse_basic_creation
 from nucliadb.writer.resource.field import parse_fields
 from nucliadb.writer.resource.origin import parse_extra, parse_origin
 from nucliadb.writer.tus import TUSUPLOAD, UPLOAD, get_dm, get_storage_manager
@@ -58,20 +57,21 @@ from nucliadb.writer.tus.exceptions import (
     InvalidTUSMetadata,
     ResumableURINotAvailable,
 )
-from nucliadb.writer.tus.storage import FileStorageManager  # type: ignore
+from nucliadb.writer.tus.storage import FileStorageManager
 from nucliadb.writer.tus.utils import parse_tus_metadata
 from nucliadb.writer.utilities import get_processing
+from nucliadb_models import content_types
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.utils import FieldIdString
 from nucliadb_models.writer import CreateResourcePayload, ResourceFileUploaded
+from nucliadb_protos.resources_pb2 import CloudFile, FieldFile, Metadata
+from nucliadb_protos.writer_pb2 import BrokerMessage
 from nucliadb_utils.authentication import requires_one
 from nucliadb_utils.exceptions import LimitsExceededError, SendToProcessError
 from nucliadb_utils.storages.storage import KB_RESOURCE_FIELD
-from nucliadb_utils.transaction import TransactionCommitTimeoutError
 from nucliadb_utils.utilities import (
     get_partitioning,
     get_storage,
-    get_transaction_utility,
 )
 
 from .router import KB_PREFIX, RESOURCE_PREFIX, RSLUG_PREFIX, api
@@ -82,6 +82,10 @@ TUS_HEADERS = {
     "Tus-Extension": "creation-defer-length",
 }
 
+ExtractStrategyHeader = Header(
+    description="Extract strategy to use when uploading a file. If not provided, the default strategy will be used.",
+)
+
 
 @api.options(
     f"/{KB_PREFIX}/{{kbid}}/{RSLUG_PREFIX}/{{rslug}}/file/{{field}}/{TUSUPLOAD}/{{upload_id}}",
@@ -142,9 +146,12 @@ async def tus_post_rslug_prefix(
     rslug: str,
     field: FieldIdString,
     item: Optional[CreateResourcePayload] = None,
+    x_extract_strategy: Annotated[Optional[str], ExtractStrategyHeader] = None,
 ) -> Response:
     rid = await get_rid_from_slug_or_raise_error(kbid, rslug)
-    return await _tus_post(request, kbid, item, path_rid=rid, field_id=field)
+    return await _tus_post(
+        request, kbid, item, path_rid=rid, field_id=field, extract_strategy=x_extract_strategy
+    )
 
 
 @api.post(
@@ -161,8 +168,11 @@ async def tus_post_rid_prefix(
     path_rid: str,
     field: FieldIdString,
     item: Optional[CreateResourcePayload] = None,
+    x_extract_strategy: Annotated[Optional[str], ExtractStrategyHeader] = None,
 ) -> Response:
-    return await _tus_post(request, kbid, item, path_rid=path_rid, field_id=field)
+    return await _tus_post(
+        request, kbid, item, path_rid=path_rid, field_id=field, extract_strategy=x_extract_strategy
+    )
 
 
 @api.post(
@@ -177,8 +187,9 @@ async def tus_post(
     request: Request,
     kbid: str,
     item: Optional[CreateResourcePayload] = None,
+    x_extract_strategy: Annotated[Optional[str], ExtractStrategyHeader] = None,
 ) -> Response:
-    return await _tus_post(request, kbid, item)
+    return await _tus_post(request, kbid, item, extract_strategy=x_extract_strategy)
 
 
 # called by one the three POST above - there are defined distinctly to produce clean API doc
@@ -188,6 +199,7 @@ async def _tus_post(
     item: Optional[CreateResourcePayload] = None,
     path_rid: Optional[str] = None,
     field_id: Optional[str] = None,
+    extract_strategy: Optional[str] = None,
 ) -> Response:
     """
     An empty POST request is used to create a new upload resource.
@@ -196,6 +208,13 @@ async def _tus_post(
     if path_rid is not None:
         await validate_rid_exists_or_raise_error(kbid, path_rid)
 
+    kb_config = await datamanagers.atomic.kb.get_config(kbid=kbid)
+    if item and item.hidden and not (kb_config and kb_config.hidden_resources_enabled):
+        raise HTTPException(
+            status_code=422,
+            detail="Cannot hide a resource: the KB does not have hidden resources enabled",
+        )
+
     await maybe_back_pressure(request, kbid, resource_uuid=path_rid)
 
     dm = get_dm()
@@ -221,15 +240,11 @@ 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: {str(exc)}")
     else:
         metadata = {}
 
-    path, rid, field = await validate_field_upload(
-        kbid, path_rid, field_id, metadata.get("md5")
-    )
+    path, rid, field = await validate_field_upload(kbid, path_rid, field_id, metadata.get("md5"))
 
     if implies_resource_creation:
         # When uploading a file to a new kb resource, we want to allow multiple
@@ -255,8 +270,15 @@ async def _tus_post(
     request_content_type = None
     if item is None:
         request_content_type = request.headers.get("content-type")
-    if not request_content_type:
-        request_content_type = guess_content_type(metadata["filename"])
+    if request_content_type is None:
+        request_content_type = content_types.guess(metadata["filename"]) or "application/octet-stream"
+
+    if request_content_type is not None and not content_types.valid(request_content_type):
+        raise HTTPException(
+            status_code=415,
+            detail=f"Unsupported content type: {request_content_type}",
+        )
+
     metadata.setdefault("content_type", request_content_type)
 
     metadata["implies_resource_creation"] = implies_resource_creation
@@ -275,6 +297,7 @@ async def _tus_post(
         deferred_length=deferred_length,
         offset=0,
         item=creation_payload,
+        extract_strategy=extract_strategy,
     )
 
     if size is not None:
@@ -286,9 +309,7 @@ async def _tus_post(
     await dm.save()
 
     # Find the URL for upload, with the same parameter as this call
-    location = api.url_path_for(
-        "Upload information", upload_id=upload_id, **request.path_params
-    )
+    location = api.url_path_for("Upload information", upload_id=upload_id, **request.path_params)
     return Response(
         status_code=201,
         headers={
@@ -465,7 +486,7 @@ async def _tus_patch(
     field: Optional[str] = None,
 ) -> Response:
     """
-    Upload all bytes in the requests and append them in the specifyied offset
+    Upload all bytes in the requests and append them in the specified offset
     """
     if rid is not None:
         await validate_rid_exists_or_raise_error(kbid, rid)
@@ -494,8 +515,7 @@ async def _tus_patch(
 
     if offset != dm.offset:
         raise HTTPConflict(
-            detail=f"Current upload offset({offset}) does not match "
-            f"object offset {dm.offset}"
+            detail=f"Current upload offset({offset}) does not match " f"object offset {dm.offset}"
         )
 
     storage_manager = get_storage_manager()
@@ -507,9 +527,7 @@ async def _tus_patch(
 
     if to_upload and read_bytes != to_upload:  # pragma: no cover
         # check length matches if provided
-        raise HTTPPreconditionFailed(
-            detail="Upload size does not match what was provided"
-        )
+        raise HTTPPreconditionFailed(detail="Upload size does not match what was provided")
     await dm.update(offset=offset + read_bytes)
 
     headers = {
@@ -521,7 +539,6 @@ async def _tus_patch(
     }
 
     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:
@@ -540,13 +557,19 @@ async def _tus_patch(
             if isinstance(item_payload, str):
                 item_payload = item_payload.encode()
             creation_payload = pickle.loads(base64.b64decode(item_payload))
+
+        content_type = dm.get("metadata", {}).get("content_type")
+        if content_type is not None and not content_types.valid(content_type):
+            return HTTPClientError(
+                status_code=415,
+                detail=f"Unsupported content type: {content_type}",
+            )
+
         try:
             seqid = await store_file_on_nuclia_db(
                 size=dm.get("size"),
-                content_type=dm.get("metadata", {}).get("content_type"),
-                override_resource_title=dm.get("metadata", {}).get(
-                    "implies_resource_creation", False
-                ),
+                content_type=content_type,
+                override_resource_title=dm.get("metadata", {}).get("implies_resource_creation", False),
                 filename=dm.get("metadata", {}).get("filename"),
                 password=dm.get("metadata", {}).get("password"),
                 language=dm.get("metadata", {}).get("language"),
@@ -559,26 +582,24 @@ async def _tus_patch(
                 request=request,
                 bucket=storage_manager.storage.get_bucket_name(kbid),
                 item=creation_payload,
+                extract_strategy=dm.get("extract_strategy") or None,
             )
         except LimitsExceededError as exc:
             raise HTTPException(status_code=exc.status_code, detail=exc.detail)
 
         headers["NDB-Seq"] = f"{seqid}"
     else:
-        check_uploaded_chunk_size(read_bytes, storage_manager)
+        validate_intermediate_tus_chunk(read_bytes, storage_manager)
         await dm.save()
 
     return Response(headers=headers)
 
 
-def check_uploaded_chunk_size(read_bytes: int, storage_manager: FileStorageManager):
-    if (
-        storage_manager.min_upload_size is not None
-        and read_bytes < storage_manager.min_upload_size
-    ):
-        raise HTTPPreconditionFailed(
-            detail=f"Intermediate chunks cannot be smaller than {storage_manager.min_upload_size} bytes"
-        )
+def validate_intermediate_tus_chunk(read_bytes: int, storage_manager: FileStorageManager):
+    try:
+        storage_manager.validate_intermediate_chunk(read_bytes)
+    except ValueError as err:
+        raise HTTPPreconditionFailed(detail=str(err))
 
 
 @api.post(
@@ -599,6 +620,7 @@ async def upload_rslug_prefix(
     x_password: Optional[list[str]] = Header(None),  # type: ignore
     x_language: Optional[list[str]] = Header(None),  # type: ignore
     x_md5: Optional[list[str]] = Header(None),  # type: ignore
+    x_extract_strategy: Annotated[Optional[str], ExtractStrategyHeader] = None,
 ) -> ResourceFileUploaded:
     rid = await get_rid_from_slug_or_raise_error(kbid, rslug)
     return await _upload(
@@ -610,6 +632,7 @@ async def upload_rslug_prefix(
         x_password=x_password,
         x_language=x_language,
         x_md5=x_md5,
+        x_extract_strategy=x_extract_strategy,
     )
 
 
@@ -631,6 +654,7 @@ async def upload_rid_prefix(
     x_password: Optional[list[str]] = Header(None),  # type: ignore
     x_language: Optional[list[str]] = Header(None),  # type: ignore
     x_md5: Optional[list[str]] = Header(None),  # type: ignore
+    x_extract_strategy: Annotated[Optional[str], ExtractStrategyHeader] = None,
 ) -> ResourceFileUploaded:
     return await _upload(
         request,
@@ -641,6 +665,7 @@ async def upload_rid_prefix(
         x_password=x_password,
         x_language=x_language,
         x_md5=x_md5,
+        x_extract_strategy=x_extract_strategy,
     )
 
 
@@ -660,6 +685,7 @@ async def upload(
     x_password: Optional[list[str]] = Header(None),  # type: ignore
     x_language: Optional[list[str]] = Header(None),  # type: ignore
     x_md5: Optional[list[str]] = Header(None),  # type: ignore
+    x_extract_strategy: Annotated[Optional[str], ExtractStrategyHeader] = None,
 ) -> ResourceFileUploaded:
     return await _upload(
         request,
@@ -668,6 +694,7 @@ async def upload(
         x_password=x_password,
         x_language=x_language,
         x_md5=x_md5,
+        x_extract_strategy=x_extract_strategy,
     )
 
 
@@ -681,6 +708,7 @@ async def _upload(
     x_password: Optional[list[str]] = Header(None),  # type: ignore
     x_language: Optional[list[str]] = Header(None),  # type: ignore
     x_md5: Optional[list[str]] = Header(None),  # type: ignore
+    x_extract_strategy: Optional[str] = None,
 ) -> ResourceFileUploaded:
     if path_rid is not None:
         await validate_rid_exists_or_raise_error(kbid, path_rid)
@@ -688,9 +716,7 @@ async def _upload(
     await maybe_back_pressure(request, kbid, resource_uuid=path_rid)
 
     md5_user = x_md5[0] if x_md5 is not None and len(x_md5) > 0 else None
-    path, rid, valid_field = await validate_field_upload(
-        kbid, path_rid, field, md5_user
-    )
+    path, rid, valid_field = await validate_field_upload(kbid, path_rid, field, md5_user)
     dm = get_dm()
     storage_manager = get_storage_manager()
 
@@ -719,8 +745,14 @@ async def _upload(
     # - content-type set by the user in the upload request header takes precedence.
     # - if not set, we will try to guess it from the filename and default to a generic binary content type otherwise
     content_type = request.headers.get("content-type")
-    if not content_type:
-        content_type = guess_content_type(filename)
+    if content_type is None:
+        content_type = content_types.guess(filename) or "application/octet-stream"
+
+    if not content_types.valid(content_type):
+        raise HTTPException(
+            status_code=415,
+            detail=f"Unsupported content type: {content_type}",
+        )
 
     metadata = {"content_type": content_type, "filename": filename}
 
@@ -770,6 +802,7 @@ async def _upload(
             path=path,
             request=request,
             bucket=storage_manager.storage.get_bucket_name(kbid),
+            extract_strategy=x_extract_strategy,
         )
     except LimitsExceededError as exc:
         raise HTTPException(status_code=exc.status_code, detail=exc.detail)
@@ -791,13 +824,9 @@ async def validate_field_upload(
     if rid is None:
         # we are going to create a new resource and a field
         if md5 is not None:
-            exists = await datamanagers.atomic.resources.resource_exists(
-                kbid=kbid, rid=md5
-            )
+            exists = await datamanagers.atomic.resources.resource_exists(kbid=kbid, rid=md5)
             if exists:
-                raise HTTPConflict(
-                    "A resource with the same uploaded file already exists"
-                )
+                raise HTTPConflict("A resource with the same uploaded file already exists")
             rid = md5
         else:
             rid = uuid.uuid4().hex
@@ -823,7 +852,7 @@ async def store_file_on_nuclia_db(
     path: str,
     request: Request,
     bucket: str,
-    source: Source,
+    source: CloudFile.Source.ValueType,
     rid: str,
     field: str,
     content_type: str = "application/octet-stream",
@@ -833,11 +862,10 @@ async def store_file_on_nuclia_db(
     language: Optional[str] = None,
     md5: Optional[str] = None,
     item: Optional[CreateResourcePayload] = None,
+    extract_strategy: Optional[str] = None,
 ) -> Optional[int]:
     # File is on NucliaDB Storage at path
-
     partitioning = get_partitioning()
-    transaction = get_transaction_utility()
     processing = get_processing()
     storage = await get_storage(service_name=SERVICE_NAME)
 
@@ -859,14 +887,17 @@ async def store_file_on_nuclia_db(
 
     parse_audit(writer.audit, request)
 
+    unique_slug_context_manager = noop_context_manager()
     if item is not None:
         if item.slug:
+            unique_slug_context_manager = ensure_slug_uniqueness(kbid, item.slug)
             writer.slug = item.slug
             toprocess.slug = item.slug
 
         toprocess.processing_options = item.processing_options
 
-        parse_basic(writer, item, toprocess)
+        kb_config = await datamanagers.atomic.kb.get_config(kbid=kbid)
+        parse_basic_creation(writer, item, toprocess, kb_config)
         if item.origin is not None:
             parse_origin(writer.origin, item.origin)
         if item.extra is not None:
@@ -882,62 +913,63 @@ async def store_file_on_nuclia_db(
             uuid=rid,
             x_skip_store=False,
         )
-
-    if override_resource_title and filename is not None:
-        set_title(writer, toprocess, filename)
-
-    writer.basic.icon = content_type
-    writer.basic.created.FromDatetime(datetime.now())
-
-    # Update resource with file
-    file_field = FieldFile()
-    file_field.added.FromDatetime(datetime.now())
-    file_field.file.bucket_name = bucket
-    file_field.file.content_type = content_type
-    if filename is not None:
-        file_field.file.filename = filename
-    file_field.file.uri = path
-    file_field.file.source = source
-
-    if md5:
-        file_field.file.md5 = md5
-    if size:
-        file_field.file.size = size
-    if language:
-        file_field.language = language
-    if password:
-        file_field.password = password
-
-    writer.files[field].CopyFrom(file_field)
-    # Do not store passwords on maindb
-    writer.files[field].ClearField("password")
-
-    toprocess.filefield[field] = await processing.convert_internal_filefield_to_str(
-        file_field, storage=storage
-    )
-
-    writer.source = BrokerMessage.MessageSource.WRITER
-    writer.basic.metadata.status = Metadata.Status.PENDING
-    writer.basic.metadata.useful = True
-    try:
-        await transaction.commit(writer, partition, wait=True)
-    except TransactionCommitTimeoutError:
-        raise HTTPException(
-            status_code=501,
-            detail="Inconsistent write. This resource will not be processed and may not be stored.",
+    else:
+        # Use defaults for everything, but don't forget hidden which depends on KB config
+        kb_config = await datamanagers.atomic.kb.get_config(kbid=kbid)
+        if kb_config and kb_config.hidden_resources_hide_on_creation:
+            writer.basic.hidden = True
+
+    async with unique_slug_context_manager:
+        if override_resource_title and filename is not None:
+            set_title(writer, toprocess, filename)
+
+        writer.basic.icon = content_type
+        writer.basic.created.FromDatetime(datetime.now())
+
+        # Update resource with file
+        file_field = FieldFile()
+        file_field.added.FromDatetime(datetime.now())
+        file_field.file.bucket_name = bucket
+        file_field.file.content_type = content_type
+        if filename is not None:
+            file_field.file.filename = filename
+        file_field.file.uri = path
+        file_field.file.source = source
+
+        if md5:
+            file_field.file.md5 = md5
+        if size:
+            file_field.file.size = size
+        if language:
+            file_field.language = language
+        if password:
+            file_field.password = password
+        if extract_strategy is not None:
+            file_field.extract_strategy = extract_strategy
+
+        writer.files[field].CopyFrom(file_field)
+        # Do not store passwords on maindb
+        writer.files[field].ClearField("password")
+
+        toprocess.filefield[field] = await processing.convert_internal_filefield_to_str(
+            file_field, storage=storage
         )
 
-    try:
-        processing_info = await processing.send_to_process(toprocess, partition)
-    except LimitsExceededError as exc:
-        raise HTTPException(status_code=exc.status_code, detail=exc.detail)
-    except SendToProcessError:
-        raise HTTPException(
-            status_code=500,
-            detail="Error while sending to process. Try calling /reprocess",
-        )
+        writer.source = BrokerMessage.MessageSource.WRITER
+        writer.basic.metadata.status = Metadata.Status.PENDING
+        writer.basic.metadata.useful = True
+        await transaction.commit(writer, partition)
+        try:
+            processing_info = await processing.send_to_process(toprocess, partition)
+        except LimitsExceededError as exc:
+            raise HTTPException(status_code=exc.status_code, detail=exc.detail)
+        except SendToProcessError:
+            raise HTTPException(
+                status_code=500,
+                detail="Error while sending to process. Try calling /reprocess",
+            )
 
-    return processing_info.seqid
+        return processing_info.seqid
 
 
 def maybe_b64decode(some_string: str) -> str:
@@ -946,9 +978,3 @@ def maybe_b64decode(some_string: str) -> str:
     except ValueError:
         # not b64encoded
         return some_string
-
-
-def guess_content_type(filename: str) -> str:
-    default = "application/octet-stream"
-    guessed, _ = mimetypes.guess_type(filename)
-    return guessed or default

nucliadb/writer/app.py

@@ -18,61 +18,38 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 
-import functools
+import importlib.metadata
 
-import pkg_resources
 from fastapi import FastAPI
 from starlette.middleware import Middleware
 from starlette.middleware.authentication import AuthenticationMiddleware
-from starlette.middleware.cors import CORSMiddleware
 from starlette.requests import ClientDisconnect
 from starlette.responses import HTMLResponse
 
-from nucliadb.common.context.fastapi import get_app_context, set_app_context
 from nucliadb.writer import API_PREFIX
 from nucliadb.writer.api.v1.router import api as api_v1
-from nucliadb.writer.lifecycle import finalize, initialize
+from nucliadb.writer.lifecycle import lifespan
 from nucliadb_telemetry import errors
 from nucliadb_telemetry.fastapi.utils import (
     client_disconnect_handler,
     global_exception_handler,
 )
-from nucliadb_utils import const
 from nucliadb_utils.authentication import NucliaCloudAuthenticationBackend
 from nucliadb_utils.fastapi.openapi import extend_openapi
 from nucliadb_utils.fastapi.versioning import VersionedFastAPI
-from nucliadb_utils.settings import http_settings, running_settings
-from nucliadb_utils.utilities import has_feature
+from nucliadb_utils.settings import running_settings
 
 middleware = []
 
-if has_feature(const.Features.CORS_MIDDLEWARE, default=False):
-    middleware.append(
-        Middleware(
-            CORSMiddleware,
-            allow_origins=http_settings.cors_origins,
-            allow_methods=["*"],
-            # Authorization will be exluded from * in the future, (CORS non-wildcard request-header).
-            # Browsers already showing deprecation notices, so it needs to be specified explicitly
-            allow_headers=["*", "Authorization"],
-        )
-    )
-
-middleware.extend(
-    [Middleware(AuthenticationMiddleware, backend=NucliaCloudAuthenticationBackend())]
-)
-
+middleware.extend([Middleware(AuthenticationMiddleware, backend=NucliaCloudAuthenticationBackend())])
 
-errors.setup_error_handling(pkg_resources.get_distribution("nucliadb").version)
 
-on_startup = [initialize]
-on_shutdown = [finalize]
+errors.setup_error_handling(importlib.metadata.distribution("nucliadb").version)
 
 fastapi_settings = dict(
     debug=running_settings.debug,
     middleware=middleware,
-    on_startup=on_startup,
-    on_shutdown=on_shutdown,
+    lifespan=lifespan,
     exception_handlers={
         Exception: global_exception_handler,
         ClientDisconnect: client_disconnect_handler,
@@ -102,18 +79,4 @@ def create_application() -> FastAPI:
     # Use raw starlette routes to avoid unnecessary overhead
     application.add_route("/", homepage)
 
-    set_app_context(application)
-    maybe_configure_back_pressure(application)
     return application
-
-
-def maybe_configure_back_pressure(application: FastAPI):
-    from nucliadb.writer.back_pressure import start_materializer, stop_materializer
-    from nucliadb.writer.settings import back_pressure_settings
-    from nucliadb_utils.settings import is_onprem_nucliadb
-
-    if back_pressure_settings.enabled and not is_onprem_nucliadb():
-        context = get_app_context(application)
-        start_materializer_with_context = functools.partial(start_materializer, context)
-        application.add_event_handler("startup", start_materializer_with_context)
-        application.add_event_handler("shutdown", stop_materializer)