nucliadb 6.7.2.post4874__py3-none-any.whl → 6.10.0.post5705__py3-none-any.whl

nucliadb/writer/api/v1/resource.py

@@ -17,13 +17,12 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
-import asyncio
 import contextlib
 from time import time
-from typing import Annotated, Optional
+from typing import Annotated
 from uuid import uuid4
 
-from fastapi import HTTPException, Query, Response
+from fastapi import BackgroundTasks, HTTPException, Query, Response
 from fastapi_versioning import version
 from starlette.requests import Request
 
@@ -498,12 +497,10 @@ async def _reprocess_resource(
 @requires(NucliaDBRoles.WRITER)
 @version(1)
 async def delete_resource_rslug_prefix(
-    request: Request,
-    kbid: str,
-    rslug: str,
+    request: Request, kbid: str, rslug: str, background: BackgroundTasks
 ):
     rid = await get_rid_from_slug_or_raise_error(kbid, rslug)
-    return await _delete_resource(request, kbid, rid)
+    return await _delete_resource(request, kbid, rid, background)
 
 
 @api.delete(
@@ -514,19 +511,11 @@ async def delete_resource_rslug_prefix(
 )
 @requires(NucliaDBRoles.WRITER)
 @version(1)
-async def delete_resource_rid_prefix(
-    request: Request,
-    kbid: str,
-    rid: str,
-):
-    return await _delete_resource(request, kbid, rid)
+async def delete_resource_rid_prefix(request: Request, kbid: str, rid: str, background: BackgroundTasks):
+    return await _delete_resource(request, kbid, rid, background)
 
 
-async def _delete_resource(
-    request: Request,
-    kbid: str,
-    rid: str,
-):
+async def _delete_resource(request: Request, kbid: str, rid: str, background: BackgroundTasks):
     await validate_rid_exists_or_raise_error(kbid, rid)
 
     partitioning = get_partitioning()
@@ -541,7 +530,7 @@ async def _delete_resource(
     parse_audit(writer.audit, request)
     await transaction.commit(writer, partition)
     processing = get_processing()
-    asyncio.create_task(processing.delete_from_processing(kbid=kbid, resource_id=rid))
+    background.add_task(processing.delete_from_processing, kbid=kbid, resource_id=rid)
 
     return Response(status_code=204)
 
@@ -637,7 +626,7 @@ def needs_resource_reindex(item: UpdateResourcePayload) -> bool:
     )
 
 
-async def maybe_send_to_process(toprocess: PushPayload, partition) -> Optional[int]:
+async def maybe_send_to_process(toprocess: PushPayload, partition) -> int | None:
     if not needs_reprocess(toprocess):
         return None
 

nucliadb/writer/api/v1/services.py

@@ -17,152 +17,22 @@
 # 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 fastapi import HTTPException, Response
+from fastapi import Body, HTTPException, Path, Response
 from fastapi_versioning import version
 from starlette.requests import Request
 
 from nucliadb.common import datamanagers
 from nucliadb.common.datamanagers.exceptions import KnowledgeBoxNotFound
 from nucliadb.common.models_utils import to_proto
-from nucliadb.models.responses import (
-    HTTPConflict,
-    HTTPInternalServerError,
-    HTTPNotFound,
-)
 from nucliadb.writer.api.v1.router import KB_PREFIX, api
 from nucliadb_models.configuration import SearchConfiguration
-from nucliadb_models.entities import (
-    CreateEntitiesGroupPayload,
-    UpdateEntitiesGroupPayload,
-)
 from nucliadb_models.labels import LabelSet
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.synonyms import KnowledgeBoxSynonyms
 from nucliadb_protos import writer_pb2
 from nucliadb_protos.knowledgebox_pb2 import Label as LabelPB
 from nucliadb_protos.knowledgebox_pb2 import LabelSet as LabelSetPB
-from nucliadb_protos.writer_pb2 import (
-    DelEntitiesRequest,
-    NewEntitiesGroupRequest,
-    NewEntitiesGroupResponse,
-    OpStatusWriter,
-    UpdateEntitiesGroupRequest,
-    UpdateEntitiesGroupResponse,
-)
 from nucliadb_utils.authentication import requires
-from nucliadb_utils.utilities import get_ingest
-
-
-@api.post(
-    f"/{KB_PREFIX}/{{kbid}}/entitiesgroups",
-    status_code=200,
-    summary="Create Knowledge Box Entities Group",
-    tags=["Knowledge Box Services"],
-    openapi_extra={"x-operation_order": 1},
-)
-@requires(NucliaDBRoles.WRITER)
-@version(1)
-async def create_entities_group(request: Request, kbid: str, item: CreateEntitiesGroupPayload):
-    ingest = get_ingest()
-
-    pbrequest: NewEntitiesGroupRequest = NewEntitiesGroupRequest()
-    pbrequest.kb.uuid = kbid
-    pbrequest.group = item.group
-    pbrequest.entities.custom = True
-    if item.title:
-        pbrequest.entities.title = item.title
-    if item.color:
-        pbrequest.entities.color = item.color
-
-    for key, entity in item.entities.items():
-        entitypb = pbrequest.entities.entities[key]
-        entitypb.value = entity.value
-        entitypb.merged = entity.merged
-        entitypb.deleted = False
-        entitypb.represents.extend(entity.represents)
-
-    status: NewEntitiesGroupResponse = await ingest.NewEntitiesGroup(pbrequest)  # type: ignore
-    if status.status == NewEntitiesGroupResponse.Status.OK:
-        return
-    elif status.status == NewEntitiesGroupResponse.Status.KB_NOT_FOUND:
-        return HTTPNotFound(detail="Knowledge Box does not exist")
-    elif status.status == NewEntitiesGroupResponse.Status.ALREADY_EXISTS:
-        return HTTPConflict(
-            detail=f"Entities group {item.group} already exists in this Knowledge box",
-        )
-    elif status.status == NewEntitiesGroupResponse.Status.ERROR:
-        return HTTPInternalServerError(detail="Error on settings entities on a Knowledge box")
-
-
-@api.patch(
-    f"/{KB_PREFIX}/{{kbid}}/entitiesgroup/{{group}}",
-    status_code=200,
-    summary="Update Knowledge Box Entities Group",
-    tags=["Knowledge Box Services"],
-    openapi_extra={"x-operation_order": 2},
-)
-@requires(NucliaDBRoles.WRITER)
-@version(1)
-async def update_entities_group(
-    request: Request, kbid: str, group: str, item: UpdateEntitiesGroupPayload
-):
-    ingest = get_ingest()
-
-    pbrequest: UpdateEntitiesGroupRequest = UpdateEntitiesGroupRequest()
-    pbrequest.kb.uuid = kbid
-    pbrequest.group = group
-    pbrequest.title = item.title or ""
-    pbrequest.color = item.color or ""
-
-    for name, entity in item.add.items():
-        entitypb = pbrequest.add[name]
-        entitypb.value = entity.value
-        entitypb.merged = entity.merged
-        entitypb.represents.extend(entity.represents)
-
-    for name, entity in item.update.items():
-        entitypb = pbrequest.update[name]
-        entitypb.value = entity.value
-        entitypb.merged = entity.merged
-        entitypb.represents.extend(entity.represents)
-
-    pbrequest.delete.extend(item.delete)
-
-    status: UpdateEntitiesGroupResponse = await ingest.UpdateEntitiesGroup(pbrequest)  # type: ignore
-    if status.status == UpdateEntitiesGroupResponse.Status.OK:
-        return
-    elif status.status == UpdateEntitiesGroupResponse.Status.KB_NOT_FOUND:
-        return HTTPNotFound(detail="Knowledge Box does not exist")
-    elif status.status == UpdateEntitiesGroupResponse.Status.ENTITIES_GROUP_NOT_FOUND:
-        return HTTPNotFound(detail="Entities group does not exist")
-    elif status.status == UpdateEntitiesGroupResponse.Status.ERROR:
-        return HTTPInternalServerError(detail="Error on settings entities on a Knowledge box")
-
-
-@api.delete(
-    f"/{KB_PREFIX}/{{kbid}}/entitiesgroup/{{group}}",
-    status_code=200,
-    summary="Delete Knowledge Box Entities",
-    tags=["Knowledge Box Services"],
-    openapi_extra={"x-operation_order": 3},
-)
-@requires(NucliaDBRoles.WRITER)
-@version(1)
-async def delete_entities(request: Request, kbid: str, group: str):
-    ingest = get_ingest()
-    pbrequest: DelEntitiesRequest = DelEntitiesRequest()
-    pbrequest.kb.uuid = kbid
-    pbrequest.group = group
-
-    status: OpStatusWriter = await ingest.DelEntities(pbrequest)  # type: ignore
-    if status.status == OpStatusWriter.Status.OK:
-        return None
-    elif status.status == OpStatusWriter.Status.NOTFOUND:
-        raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
-    elif status.status == OpStatusWriter.Status.ERROR:
-        raise HTTPException(status_code=500, detail="Error on deleting entities from a Knowledge box")
-
-    return Response(status_code=204)
 
 
 @api.post(
@@ -174,7 +44,15 @@ async def delete_entities(request: Request, kbid: str, group: str):
 )
 @requires(NucliaDBRoles.WRITER)
 @version(1)
-async def set_labelset_endpoint(request: Request, kbid: str, labelset: str, item: LabelSet):
+async def set_labelset_endpoint(
+    request: Request,
+    kbid: str,
+    labelset: str = Path(
+        title="The ID of the labelset to create or update. This is a unique identifier that should be used at search time.",
+        examples=["categories", "movie-genres", "document-types"],
+    ),
+    item: LabelSet = Body(...),
+):
     if item.title is None:
         item.title = labelset
 

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 (
         [