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

nucliadb/standalone/auth.py

@@ -81,9 +81,7 @@ class AuthHeaderAuthenticationBackend(NucliaCloudAuthenticationBackend):
     def __init__(self, settings: Settings) -> None:
         self.settings = settings
 
-    async def authenticate(
-        self, request: HTTPConnection
-    ) -> Optional[tuple[AuthCredentials, BaseUser]]:
+    async def authenticate(self, request: HTTPConnection) -> Optional[tuple[AuthCredentials, BaseUser]]:
         token_resp = await authenticate_auth_token(self.settings, request)
         if token_resp is not None:
             return token_resp
@@ -94,9 +92,7 @@ class AuthHeaderAuthenticationBackend(NucliaCloudAuthenticationBackend):
         user = request.headers[self.settings.auth_policy_user_header]
         nuclia_user: BaseUser = NucliaUser(username=user)
 
-        auth_creds = AuthCredentials(
-            get_mapped_roles(settings=self.settings, data={"user": user})
-        )
+        auth_creds = AuthCredentials(get_mapped_roles(settings=self.settings, data={"user": user}))
 
         return auth_creds, nuclia_user
 
@@ -113,9 +109,7 @@ class OAuth2AuthenticationBackend(NucliaCloudAuthenticationBackend):
     def __init__(self, settings: Settings) -> None:
         self.settings = settings
 
-    async def authenticate(
-        self, request: HTTPConnection
-    ) -> Optional[tuple[AuthCredentials, BaseUser]]:
+    async def authenticate(self, request: HTTPConnection) -> Optional[tuple[AuthCredentials, BaseUser]]:
         token_resp = await authenticate_auth_token(self.settings, request)
         if token_resp is not None:
             return token_resp
@@ -133,9 +127,7 @@ class OAuth2AuthenticationBackend(NucliaCloudAuthenticationBackend):
         try:
             token_data = orjson.loads(base64.b64decode(token_split[1] + "==="))
         except Exception:
-            logger.warning(
-                f"Could not parse jwt bearer token value: {token}", exc_info=True
-            )
+            logger.warning(f"Could not parse jwt bearer token value: {token}", exc_info=True)
             return None
 
         if "sub" not in token_data:
@@ -168,9 +160,7 @@ class BasicAuthAuthenticationBackend(NucliaCloudAuthenticationBackend):
     def __init__(self, settings: Settings) -> None:
         self.settings = settings
 
-    async def authenticate(
-        self, request: HTTPConnection
-    ) -> Optional[tuple[AuthCredentials, BaseUser]]:
+    async def authenticate(self, request: HTTPConnection) -> Optional[tuple[AuthCredentials, BaseUser]]:
         token_resp = await authenticate_auth_token(self.settings, request)
         if token_resp is not None:
             return token_resp
@@ -186,9 +176,7 @@ class BasicAuthAuthenticationBackend(NucliaCloudAuthenticationBackend):
         user = token.split(":")[0]
 
         nuclia_user: BaseUser = NucliaUser(username=user)
-        auth_creds = AuthCredentials(
-            get_mapped_roles(settings=self.settings, data={"user": user})
-        )
+        auth_creds = AuthCredentials(get_mapped_roles(settings=self.settings, data={"user": user}))
 
         return auth_creds, nuclia_user
 
@@ -201,9 +189,7 @@ class UpstreamNaiveAuthenticationBackend(NucliaCloudAuthenticationBackend):
             user_header=settings.auth_policy_user_header,
         )
 
-    async def authenticate(
-        self, request: HTTPConnection
-    ) -> Optional[tuple[AuthCredentials, BaseUser]]:
+    async def authenticate(self, request: HTTPConnection) -> Optional[tuple[AuthCredentials, BaseUser]]:
         token_resp = await authenticate_auth_token(self.settings, request)
         if token_resp is not None:
             return token_resp

nucliadb/standalone/config.py

@@ -44,12 +44,9 @@ def config_standalone_driver(nucliadb_args: Settings):
 
     if ingest_settings.driver == DriverConfig.NOT_SET:
         # no driver specified, for standalone, we force defaulting to local here
-        ingest_settings.driver = DriverConfig.LOCAL
+        ingest_settings.driver = DriverConfig.PG
 
-    if (
-        ingest_settings.driver == DriverConfig.LOCAL
-        and ingest_settings.driver_local_url is None
-    ):
+    if ingest_settings.driver == DriverConfig.LOCAL and ingest_settings.driver_local_url is None:
         # also provide default path for local driver when none provided
         ingest_settings.driver_local_url = "./data/main"
 
@@ -57,11 +54,11 @@ def config_standalone_driver(nucliadb_args: Settings):
         # no driver specified, for standalone, we try to automate some settings here
         storage_settings.file_backend = FileBackendConfig.LOCAL
 
-    if (
-        storage_settings.file_backend == FileBackendConfig.LOCAL
-        and storage_settings.local_files is None
-    ):
-        storage_settings.local_files = "./data/blob"
+    if storage_settings.file_backend == FileBackendConfig.LOCAL:
+        if storage_settings.local_files is None:
+            storage_settings.local_files = "./data/blob"
+        if storage_settings.local_indexing_bucket is None:
+            storage_settings.local_indexing_bucket = "indexer"
 
     if ingest_settings.driver_local_url is not None and not os.path.isdir(
         ingest_settings.driver_local_url

nucliadb/standalone/lifecycle.py

@@ -18,48 +18,49 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import asyncio
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
 
 from nucliadb.common.cluster.utils import setup_cluster, teardown_cluster
+from nucliadb.common.context.fastapi import inject_app_context
 from nucliadb.ingest.app import initialize_grpc as initialize_ingest_grpc
 from nucliadb.ingest.app import initialize_pull_workers
 from nucliadb.ingest.settings import settings as ingest_settings
-from nucliadb.reader.lifecycle import finalize as finalize_reader
-from nucliadb.reader.lifecycle import initialize as initialize_reader
-from nucliadb.search.lifecycle import finalize as finalize_search
-from nucliadb.search.lifecycle import initialize as initialize_search
-from nucliadb.train.lifecycle import finalize as finalize_train
-from nucliadb.train.lifecycle import initialize as initialize_train
-from nucliadb.writer.lifecycle import finalize as finalize_writer
-from nucliadb.writer.lifecycle import initialize as initialize_writer
+from nucliadb.reader.lifecycle import lifespan as reader_lifespan
+from nucliadb.search.lifecycle import lifespan as search_lifespan
+from nucliadb.train.lifecycle import lifespan as train_lifespan
+from nucliadb.writer.lifecycle import lifespan as writer_lifespan
 from nucliadb_utils.utilities import finalize_utilities
 
 SYNC_FINALIZERS = []
 
 
-async def initialize():
+@asynccontextmanager
+async def lifespan(app: FastAPI):
     if ingest_settings.disable_pull_worker:
         finalizers = await initialize_ingest_grpc()
     else:
         finalizers = await initialize_pull_workers()
     SYNC_FINALIZERS.extend(finalizers)
-    await initialize_writer()
-    await initialize_reader()
-    await initialize_search()
-    await initialize_train()
-    await setup_cluster()
 
+    async with (
+        writer_lifespan(app),
+        reader_lifespan(app),
+        search_lifespan(app),
+        train_lifespan(app),
+        inject_app_context(app),
+    ):
+        await setup_cluster()
+
+        yield
 
-async def finalize():
-    for finalizer in SYNC_FINALIZERS:
-        if asyncio.iscoroutinefunction(finalizer):
-            await finalizer()
-        else:
-            finalizer()
-    SYNC_FINALIZERS.clear()
+        for finalizer in SYNC_FINALIZERS:
+            if asyncio.iscoroutinefunction(finalizer):
+                await finalizer()
+            else:
+                finalizer()
+        SYNC_FINALIZERS.clear()
 
-    await finalize_writer()
-    await finalize_reader()
-    await finalize_search()
-    await finalize_train()
     await finalize_utilities()
     await teardown_cluster()

nucliadb/standalone/migrations.py

@@ -54,7 +54,5 @@ async def safe_run_migrations():
             await run_migrator(forever=False)
             break
         except locking.ResourceLocked:
-            sys.stdout.write(
-                "Another worker is already running migrations. Waiting...\n"
-            )
+            sys.stdout.write("Another worker is already running migrations. Waiting...\n")
             continue

nucliadb/standalone/purge.py

@@ -25,7 +25,7 @@ import argdantic
 from nucliadb.standalone.config import config_nucliadb
 from nucliadb.standalone.settings import Settings
 
-parser = argdantic.ArgParser()
+parser: argdantic.ArgParser = argdantic.ArgParser()
 
 
 @parser.command(singleton=True, name="NucliaDB", help="NucliaDB Starting script")

nucliadb/standalone/run.py

@@ -42,7 +42,7 @@ from nucliadb_utils.settings import nuclia_settings, storage_settings
 logger = logging.getLogger(__name__)
 
 
-parser = argdantic.ArgParser()
+parser: argdantic.ArgParser = argdantic.ArgParser()
 
 
 @parser.command(singleton=True, name="NucliaDB", help="NucliaDB Starting script")
@@ -98,7 +98,7 @@ def run():
         "API": f"http://{settings.http_host}:{settings.http_port}/api",
         "Admin UI": f"http://{settings.http_host}:{settings.http_port}/admin",
         "Key-value backend": ingest_settings.driver.value,
-        "Blog storage backend": storage_settings.file_backend.value,
+        "Blob storage backend": storage_settings.file_backend.value,
         "Cluster discovery mode": cluster_settings.cluster_discovery_mode.value,
         "Node replicas": cluster_settings.node_replicas,
         "Index data path": os.path.realpath(cluster_settings.data_path),
@@ -121,10 +121,7 @@ def run():
         settings_to_output["NUA API zone"] = nuclia_settings.nuclia_zone
 
     settings_to_output_fmted = "\n".join(
-        [
-            f"||      - {k}:{' ' * (27 - len(k))}{v}"
-            for k, v in settings_to_output.items()
-        ]
+        [f"||      - {k}:{' ' * (27 - len(k))}{v}" for k, v in settings_to_output.items()]
     )
 
     installed_version = versions.installed_nucliadb()

nucliadb/standalone/settings.py

@@ -27,6 +27,7 @@ from nucliadb.ingest.settings import DriverSettings
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_telemetry.settings import LogFormatType, LogLevel, LogOutputType
 from nucliadb_utils.settings import StorageSettings
+from nucliadb_utils.storages.settings import Settings as ExtendedStorageSettings
 
 
 class StandaloneDiscoveryMode(Enum):
@@ -43,29 +44,23 @@ class AuthPolicy(Enum):
     UPSTREAM_BASICAUTH = "upstream_basicauth"
 
 
-class Settings(DriverSettings, StorageSettings):
+class Settings(DriverSettings, StorageSettings, ExtendedStorageSettings):
     # be consistent here with DATA_PATH env var
-    data_path: str = pydantic.Field(
-        "./data/node", description="Path to node index files"
-    )
+    data_path: str = pydantic.Field("./data/node", description="Path to node index files")
 
     # all settings here are mapped in to other env var settings used
     # in the app. These are helper settings to make things easier to
     # use with standalone app vs cluster app.
     nua_api_key: Optional[str] = pydantic.Field(
         default=None,
-        description="Nuclia Understanding API Key. Read how to generate a NUA Key here: https://docs.nuclia.dev/docs/docs/using/understanding/intro#get-a-nua-key",  # noqa
-    )
-    zone: Optional[str] = pydantic.Field(
-        default=None, description="Nuclia Understanding API Zone ID"
+        description="Nuclia Understanding API Key. Read how to generate a NUA Key here: https://docs.nuclia.dev/docs/rag/advanced/understanding/intro#get-a-nua-key",  # noqa
     )
+    zone: Optional[str] = pydantic.Field(default=None, description="Nuclia Understanding API Zone ID")
     http_host: str = pydantic.Field(default="0.0.0.0", description="HTTP Port")
     http_port: int = pydantic.Field(default=8080, description="HTTP Port")
     ingest_grpc_port: int = pydantic.Field(default=8030, description="Ingest GRPC Port")
     train_grpc_port: int = pydantic.Field(default=8031, description="Train GRPC Port")
-    standalone_node_port: int = pydantic.Field(
-        default=10009, description="Node GRPC Port"
-    )
+    standalone_node_port: int = pydantic.Field(default=10009, description="Node GRPC Port")
 
     auth_policy: AuthPolicy = pydantic.Field(
         default=AuthPolicy.UPSTREAM_NAIVE,
@@ -93,10 +88,9 @@ class Settings(DriverSettings, StorageSettings):
         description="Default role to assign to user that is authenticated \
                     upstream. Not used with `upstream_naive` auth policy.",
     )
-    auth_policy_role_mapping: Optional[dict[str, dict[str, list[NucliaDBRoles]]]] = (
-        pydantic.Field(
-            default=None,
-            description="""
+    auth_policy_role_mapping: Optional[dict[str, dict[str, list[NucliaDBRoles]]]] = pydantic.Field(
+        default=None,
+        description="""
 Role mapping for `upstream_auth_header`, `upstream_oauth2` and `upstream_basicauth` auth policies.
 Allows mapping different properties from the auth request to a role.
 Available roles are: `READER`, `WRITER`, `MANAGER`.
@@ -106,7 +100,6 @@ Examples:
 - `{"group": {"managers": "MANAGER"}}` will map the users that have a `group` claim of
   `managers` on the jwt provided by upstream to the role `MANAGER` on `upstream_oauth2` policies.
 """,
-        )
     )
 
     jwk_key: Optional[str] = pydantic.Field(

nucliadb/standalone/versions.py

@@ -18,10 +18,10 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import enum
+import importlib.metadata
 import logging
 from typing import Optional
 
-import pkg_resources
 from cachetools import TTLCache
 
 from nucliadb.common.http_clients.pypi import PyPi
@@ -65,14 +65,24 @@ def is_newer_release(installed: str, latest: str) -> bool:
     >>> is_newer_release("1.2.3", "1.2.3.post1")
     False
     """
-    parsed_installed = pkg_resources.parse_version(_release(installed))
-    parsed_latest = pkg_resources.parse_version(_release(latest))
+
+    def parse_version(version: str) -> tuple[int, int, int]:
+        parts = version.split(".")
+        if len(parts) > 3:
+            raise ValueError(f"Invalid version string: {version}")
+        major = int(parts[0]) if len(parts) >= 1 else 0
+        minor = int(parts[1]) if len(parts) >= 2 else 0
+        patch = int(parts[2]) if len(parts) == 3 else 0
+        return (major, minor, patch)
+
+    parsed_installed = parse_version(_release(installed))
+    parsed_latest = parse_version(_release(latest))
     return parsed_latest > parsed_installed
 
 
 def _release(version: str) -> str:
     """
-    Strips the .postX part of the version so that wecan compare major.minor.patch only.
+    Strips the .postX part of the version so that we can compare major.minor.patch only.
 
     >>> _release("1.2.3")
     '1.2.3'
@@ -83,7 +93,7 @@ def _release(version: str) -> str:
 
 
 def get_installed_version(package_name: str) -> str:
-    return pkg_resources.get_distribution(package_name).version
+    return importlib.metadata.distribution(package_name).version
 
 
 async def get_latest_version(package: str) -> Optional[str]:

nucliadb/tasks/consumer.py

@@ -60,7 +60,9 @@ class NatsTaskConsumer:
     async def initialize(self, context: ApplicationContext):
         self.context = context
         await create_nats_stream_if_not_exists(
-            self.context, self.stream.name, subjects=[self.stream.subject]  # type: ignore
+            self.context,
+            self.stream.name,  # type: ignore
+            subjects=[self.stream.subject],  # type: ignore
         )
         await self._setup_nats_subscription()
         self.initialized = True
@@ -128,11 +130,9 @@ class NatsTaskConsumer:
             f"Message received: subject:{subject}, seqid: {seqid}, reply: {reply}",
             extra={"consumer_name": self.name},
         )
-        async with MessageProgressUpdater(
-            msg, nats_consumer_settings.nats_ack_wait * 0.66
-        ):
+        async with MessageProgressUpdater(msg, nats_consumer_settings.nats_ack_wait * 0.66):
             try:
-                task_msg = self.msg_type.parse_raw(msg.data)
+                task_msg = self.msg_type.model_validate_json(msg.data)
             except pydantic.ValidationError as e:
                 errors.capture_exception(e)
                 logger.error(
@@ -144,9 +144,7 @@ class NatsTaskConsumer:
                 await msg.ack()
                 return
 
-            logger.info(
-                f"Starting task consumption", extra={"consumer_name": self.name}
-            )
+            logger.info(f"Starting task consumption", extra={"consumer_name": self.name})
             try:
                 await self.callback(self.context, task_msg)  # type: ignore
             except asyncio.CancelledError:
@@ -200,9 +198,7 @@ def create_consumer(
     return consumer
 
 
-async def start_consumer(
-    task_name: str, context: ApplicationContext
-) -> NatsTaskConsumer:
+async def start_consumer(task_name: str, context: ApplicationContext) -> NatsTaskConsumer:
     """
     Returns an initialized consumer for the given task name, ready to consume messages from the task stream.
     """
@@ -214,7 +210,7 @@ async def start_consumer(
         name=f"{task_name}_consumer",
         stream=task.stream,
         callback=task.callback,  # type: ignore
-        msg_type=task.msg_type,  # type: ignore
+        msg_type=task.msg_type,
         max_concurrent_messages=task.max_concurrent_messages,
     )
     await consumer.initialize(context)

nucliadb/tasks/producer.py

@@ -44,11 +44,13 @@ class NatsTaskProducer:
     async def initialize(self, context: ApplicationContext):
         self.context = context
         await create_nats_stream_if_not_exists(
-            self.context, self.stream.name, subjects=[self.stream.subject]  # type: ignore
+            self.context,
+            self.stream.name,  # type: ignore
+            subjects=[self.stream.subject],  # type: ignore
         )
         self.initialized = True
 
-    async def __call__(self, msg: MsgType) -> int:  # type: ignore
+    async def __call__(self, msg: MsgType) -> int:
         """
         Publish message to the producer's nats stream.
         Returns the sequence number of the published message.
@@ -57,7 +59,8 @@ class NatsTaskProducer:
             raise RuntimeError("NatsTaskProducer not initialized")
         try:
             pub_ack = await self.context.nats_manager.js.publish(  # type: ignore
-                self.stream.subject, msg.json().encode("utf-8")  # type: ignore
+                self.stream.subject,  # type: ignore
+                msg.model_dump_json().encode("utf-8"),  # type: ignore
             )
             logger.info(
                 "Message sent to Nats",
@@ -93,8 +96,6 @@ async def get_producer(task_name: str, context: ApplicationContext) -> NatsTaskP
         task = get_registered_task(task_name)
     except KeyError:
         raise ValueError(f"Task {task_name} not registered")
-    producer = create_producer(
-        name=f"{task_name}_producer", stream=task.stream, msg_type=task.msg_type
-    )
+    producer = create_producer(name=f"{task_name}_producer", stream=task.stream, msg_type=task.msg_type)
     await producer.initialize(context)
     return producer

nucliadb/tests/config.py

@@ -0,0 +1,53 @@
+# Copyright (C) 2021 Bosutech XXI S.L.
+#
+# nucliadb is offered under the AGPL v3.0 and as commercial software.
+# For commercial licensing, contact us at info@nuclia.com.
+#
+# AGPL:
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+# This is a test fixture which is useful outside nucliadb tests. In particular
+# it is used for the testbed. Keeping it under src so it can be imported outside
+def reset_config():
+    from nucliadb.common.cluster import settings as cluster_settings
+    from nucliadb.ingest import settings as ingest_settings
+    from nucliadb.train import settings as train_settings
+    from nucliadb.writer import settings as writer_settings
+    from nucliadb_utils import settings as utils_settings
+    from nucliadb_utils.cache import settings as cache_settings
+
+    all_settings = [
+        cluster_settings.settings,
+        ingest_settings.settings,
+        train_settings.settings,
+        writer_settings.settings,
+        cache_settings.settings,
+        utils_settings.audit_settings,
+        utils_settings.http_settings,
+        utils_settings.indexing_settings,
+        utils_settings.nuclia_settings,
+        utils_settings.nucliadb_settings,
+        utils_settings.storage_settings,
+        utils_settings.transaction_settings,
+    ]
+    for settings in all_settings:
+        defaults = type(settings)()
+        for attr, _value in settings:
+            default_value = getattr(defaults, attr)
+            setattr(settings, attr, default_value)
+
+    from nucliadb.common.cluster import manager
+
+    manager.INDEX_NODES.clear()

nucliadb/train/__init__.py

@@ -28,9 +28,7 @@ logger = logging.getLogger(SERVICE_NAME)
 class EndpointFilter(logging.Filter):
     def filter(self, record: logging.LogRecord) -> bool:
         return (
-            record.args is not None
-            and len(record.args) >= 3
-            and record.args[2] not in ("/", "/metrics")  # type: ignore
+            record.args is not None and len(record.args) >= 3 and record.args[2] not in ("/", "/metrics")  # type: ignore
         )
 
 

nucliadb/train/api/utils.py

@@ -21,9 +21,8 @@
 
 from typing import Optional
 
-from nucliadb_protos.dataset_pb2 import TrainSet
-
 from nucliadb.train.utils import get_shard_manager
+from nucliadb_protos.dataset_pb2 import TrainSet
 
 
 async def get_kb_partitions(kbid: str, prefix: Optional[str] = None):

nucliadb/train/api/v1/shards.py

@@ -21,7 +21,7 @@
 
 from fastapi import HTTPException, Request
 from fastapi.responses import StreamingResponse
-from fastapi_versioning import version  # type: ignore
+from fastapi_versioning import version
 
 from nucliadb.train.api.utils import get_kb_partitions, get_train
 from nucliadb.train.api.v1.router import KB_PREFIX, api

nucliadb/train/api/v1/trainset.py

@@ -21,7 +21,7 @@
 from typing import Optional
 
 from fastapi import Request
-from fastapi_versioning import version  # type: ignore
+from fastapi_versioning import version
 
 from nucliadb.train.api.utils import get_kb_partitions
 from nucliadb.train.api.v1.router import KB_PREFIX, api
@@ -52,9 +52,7 @@ async def get_partitions_all(request: Request, kbid: str) -> TrainSetPartitions:
 )
 @requires_one([NucliaDBRoles.READER])
 @version(1)
-async def get_partitions_prefix(
-    request: Request, kbid: str, prefix: str
-) -> TrainSetPartitions:
+async def get_partitions_prefix(request: Request, kbid: str, prefix: str) -> TrainSetPartitions:
     return await get_partitions(kbid, prefix=prefix)
 
 

nucliadb/train/app.py

@@ -17,65 +17,44 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
-import pkg_resources
+import importlib.metadata
+
 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, Request
 from starlette.responses import HTMLResponse
 
-from nucliadb.middleware.transaction import ReadOnlyTransactionMiddleware
 from nucliadb.train import API_PREFIX
 from nucliadb.train.api.v1.router import api
-from nucliadb.train.lifecycle import finalize, initialize
+from nucliadb.train.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.audit.stream import AuditMiddleware
 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
+from nucliadb_utils.utilities import get_audit
 
 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(ReadOnlyTransactionMiddleware),
+        Middleware(AuthenticationMiddleware, backend=NucliaCloudAuthenticationBackend()),
+        Middleware(AuditMiddleware, audit_utility_getter=get_audit),
     ]
 )
 
-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,