nucliadb 2.46.1.post382__py3-none-any.whl → 6.2.1.post2777__py3-none-any.whl

nucliadb/reader/api/v1/resource.py

@@ -22,22 +22,21 @@ from typing import Optional, Union
 from fastapi import Header, HTTPException, Query, Request, Response
 from fastapi_versioning import version
 
-import nucliadb_models as models
+from nucliadb.common.datamanagers.resources import KB_RESOURCE_SLUG_BASE
 from nucliadb.common.maindb.utils import get_driver
+from nucliadb.common.models_utils import from_proto, to_proto
 from nucliadb.ingest.fields.conversation import Conversation
 from nucliadb.ingest.orm.knowledgebox import KnowledgeBox as ORMKnowledgeBox
-from nucliadb.ingest.orm.resource import KB_RESOURCE_SLUG_BASE
 from nucliadb.ingest.orm.resource import Resource as ORMResource
 from nucliadb.ingest.serialize import (
     managed_serialize,
     serialize,
     set_resource_field_extracted_data,
 )
-from nucliadb.reader import SERVICE_NAME  # type: ignore
+from nucliadb.reader import SERVICE_NAME
 from nucliadb.reader.api import DEFAULT_RESOURCE_LIST_PAGE_SIZE
 from nucliadb.reader.api.models import (
     FIELD_NAME_TO_EXTRACTED_DATA_FIELD_MAP,
-    FIELD_NAMES_TO_PB_TYPE_MAP,
     ResourceField,
 )
 from nucliadb.reader.api.v1.router import KB_PREFIX, RESOURCE_PREFIX, RSLUG_PREFIX, api
@@ -77,60 +76,55 @@ async def list_resources(
 
     # Get counters from maindb
     driver = get_driver()
-    txn = await driver.begin()
-
-    # Filter parameters for serializer
-    show: list[ResourceProperties] = [ResourceProperties.BASIC]
-    field_types: list[FieldTypeName] = []
-    extracted: list[ExtractedDataTypeName] = []
-
-    try:
-        resources: list[Resource] = []
-        max_items_to_iterate = (page + 1) * size
-        first_wanted_item_index = (page * size) + 1  # 1-based index
-        current_key_index = 0
-
-        # ask for one item more than we need, in order to know if it's the last page
-        keys_generator = txn.keys(
-            match=KB_RESOURCE_SLUG_BASE.format(kbid=kbid),
-            count=max_items_to_iterate + 1,
-        )
-        async for key in keys_generator:
-            current_key_index += 1
-
-            # First of all, we need to skip keys, in case we are on a +1 page
-            if page > 0 and current_key_index < first_wanted_item_index:
-                continue
-
-            # Don't fetch keys once we got all items for this
-            if len(resources) == size:
-                await keys_generator.aclose()
-                break
-
-            # Fetch and Add wanted item
-            rid = await txn.get(key)
-            if rid:
-                result = await managed_serialize(
-                    txn,
-                    kbid,
-                    rid.decode(),
-                    show,
-                    field_types,
-                    extracted,
-                    service_name=SERVICE_NAME,
-                )
-                if result is not None:
-                    resources.append(result)
-
-        is_last_page = current_key_index <= max_items_to_iterate
-
-    except Exception as exc:
-        errors.capture_exception(exc)
-        raise HTTPException(
-            status_code=500, detail="Couldn't retrieve list of resources right now"
-        )
-    finally:
-        await txn.abort()
+    async with driver.transaction(read_only=True) as txn:
+        # Filter parameters for serializer
+        show: list[ResourceProperties] = [ResourceProperties.BASIC]
+        field_types: list[FieldTypeName] = []
+        extracted: list[ExtractedDataTypeName] = []
+
+        try:
+            resources: list[Resource] = []
+            max_items_to_iterate = (page + 1) * size
+            first_wanted_item_index = (page * size) + 1  # 1-based index
+            current_key_index = 0
+
+            # ask for one item more than we need, in order to know if it's the last page
+            keys_generator = txn.keys(
+                match=KB_RESOURCE_SLUG_BASE.format(kbid=kbid),
+                count=max_items_to_iterate + 1,
+            )
+            async for key in keys_generator:
+                current_key_index += 1
+
+                # First of all, we need to skip keys, in case we are on a +1 page
+                if page > 0 and current_key_index < first_wanted_item_index:
+                    continue
+
+                # Don't fetch keys once we got all items for this
+                if len(resources) == size:
+                    await keys_generator.aclose()
+                    break
+
+                # Fetch and Add wanted item
+                rid = await txn.get(key, for_update=False)
+                if rid:
+                    result = await managed_serialize(
+                        txn,
+                        kbid,
+                        rid.decode(),
+                        show,
+                        field_types,
+                        extracted,
+                        service_name=SERVICE_NAME,
+                    )
+                    if result is not None:
+                        resources.append(result)
+
+            is_last_page = current_key_index <= max_items_to_iterate
+
+        except Exception as exc:
+            errors.capture_exception(exc)
+            raise HTTPException(status_code=500, detail="Couldn't retrieve list of resources right now")
 
     return ResourceList(
         resources=resources,
@@ -141,7 +135,7 @@ async def list_resources(
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/{RESOURCE_PREFIX}/{{rid}}",
     status_code=200,
-    name="Get Resource (by id)",
+    summary="Get Resource (by id)",
     response_model=Resource,
     response_model_exclude_unset=True,
     tags=["Resources"],
@@ -153,9 +147,7 @@ async def get_resource_by_uuid(
     kbid: str,
     rid: str,
     show: list[ResourceProperties] = Query([ResourceProperties.BASIC]),
-    field_type_filter: list[FieldTypeName] = Query(
-        list(FieldTypeName), alias="field_type"
-    ),
+    field_type_filter: list[FieldTypeName] = Query(list(FieldTypeName), alias="field_type"),
     extracted: list[ExtractedDataTypeName] = Query(
         [
             ExtractedDataTypeName.TEXT,
@@ -181,7 +173,7 @@ async def get_resource_by_uuid(
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/{RSLUG_PREFIX}/{{rslug}}",
     status_code=200,
-    name="Get Resource (by slug)",
+    summary="Get Resource (by slug)",
     response_model=Resource,
     response_model_exclude_unset=True,
     tags=["Resources"],
@@ -193,9 +185,7 @@ async def get_resource_by_slug(
     kbid: str,
     rslug: str,
     show: list[ResourceProperties] = Query([ResourceProperties.BASIC]),
-    field_type_filter: list[FieldTypeName] = Query(
-        list(FieldTypeName), alias="field_type"
-    ),
+    field_type_filter: list[FieldTypeName] = Query(list(FieldTypeName), alias="field_type"),
     extracted: list[ExtractedDataTypeName] = Query(
         [
             ExtractedDataTypeName.TEXT,
@@ -235,7 +225,7 @@ async def _get_resource(
     audit = get_audit()
     if audit is not None:
         audit_id = rid if rid else rslug
-        await audit.visited(kbid, audit_id, x_nucliadb_user, x_forwarded_for)  # type: ignore
+        audit.visited(kbid, audit_id, x_nucliadb_user, x_forwarded_for)  # type: ignore
 
     result = await serialize(
         kbid,
@@ -254,7 +244,7 @@ async def _get_resource(
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/{RSLUG_PREFIX}/{{rslug}}/{{field_type}}/{{field_id}}",
     status_code=200,
-    name="Get Resource field (by slug)",
+    summary="Get Resource field (by slug)",
     response_model=ResourceField,
     response_model_exclude_unset=True,
     tags=["Resource fields"],
@@ -294,7 +284,7 @@ async def get_resource_field_rslug_prefix(
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/{RESOURCE_PREFIX}/{{rid}}/{{field_type}}/{{field_id}}",
     status_code=200,
-    name="Get Resource field (by id)",
+    summary="Get Resource field (by id)",
     response_model=ResourceField,
     response_model_exclude_unset=True,
     tags=["Resource fields"],
@@ -343,9 +333,7 @@ async def _get_resource_field(
 ) -> Response:
     storage = await get_storage(service_name=SERVICE_NAME)
     driver = get_driver()
-
-    pb_field_id = FIELD_NAMES_TO_PB_TYPE_MAP[field_type]
-
+    pb_field_id = to_proto.field_type_name(field_type)
     async with driver.transaction() as txn:
         kb = ORMKnowledgeBox(txn, storage, kbid)
 
@@ -360,34 +348,22 @@ async def _get_resource_field(
         if field is None:
             raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
 
-        resource_field = ResourceField(field_id=field_id, field_type=field_type)  # type: ignore
+        resource_field = ResourceField(field_id=field_id, field_type=field_type)
 
         if ResourceFieldProperties.VALUE in show:
             value = await field.get_value()
 
             if isinstance(value, resources_pb2.FieldText):
                 value = await field.get_value()
-                resource_field.value = models.FieldText.from_message(value)
+                resource_field.value = from_proto.field_text(value)
 
             if isinstance(value, resources_pb2.FieldFile):
                 value = await field.get_value()
-                resource_field.value = models.FieldFile.from_message(value)
+                resource_field.value = from_proto.field_file(value)
 
             if isinstance(value, resources_pb2.FieldLink):
                 value = await field.get_value()
-                resource_field.value = models.FieldLink.from_message(value)
-
-            if isinstance(value, resources_pb2.FieldLayout):
-                value = await field.get_value()
-                resource_field.value = models.FieldLayout.from_message(value)
-
-            if isinstance(value, resources_pb2.FieldDatetime):
-                value = await field.get_value()
-                resource_field.value = models.FieldDatetime.from_message(value)
-
-            if isinstance(value, resources_pb2.FieldKeywordset):
-                value = await field.get_value()
-                resource_field.value = models.FieldKeywordset.from_message(value)
+                resource_field.value = from_proto.field_link(value)
 
             if isinstance(field, Conversation):
                 if page == "first":
@@ -400,12 +376,10 @@ async def _get_resource_field(
 
                 value = await field.get_value(page=page_to_fetch)
                 if value is not None:
-                    resource_field.value = models.Conversation.from_message(value)
+                    resource_field.value = from_proto.conversation(value)
 
         if ResourceFieldProperties.EXTRACTED in show and extracted:
-            resource_field.extracted = FIELD_NAME_TO_EXTRACTED_DATA_FIELD_MAP[
-                field_type
-            ]()
+            resource_field.extracted = FIELD_NAME_TO_EXTRACTED_DATA_FIELD_MAP[field_type]()
             await set_resource_field_extracted_data(
                 field,
                 resource_field.extracted,
@@ -419,6 +393,6 @@ async def _get_resource_field(
                 resource_field.error = Error(body=error.error, code=error.code)
 
     return Response(
-        content=resource_field.json(exclude_unset=True, by_alias=True),
+        content=resource_field.model_dump_json(exclude_unset=True, by_alias=True),
         media_type="application/json",
     )

nucliadb/reader/api/v1/services.py

@@ -22,30 +22,17 @@ from typing import Optional, Union
 
 from fastapi import HTTPException
 from fastapi.responses import StreamingResponse
-from fastapi_versioning import version  # type: ignore
+from fastapi_versioning import version
 from google.protobuf.json_format import MessageToDict
-from nucliadb_protos.knowledgebox_pb2 import KnowledgeBoxID
-from nucliadb_protos.writer_pb2 import (
-    GetEntitiesGroupRequest,
-    GetEntitiesGroupResponse,
-    GetLabelSetRequest,
-    GetLabelSetResponse,
-    GetLabelsRequest,
-    GetLabelsResponse,
-    GetSynonymsResponse,
-    GetVectorSetsRequest,
-    GetVectorSetsResponse,
-    ListEntitiesGroupsRequest,
-    ListEntitiesGroupsResponse,
-    OpStatusWriter,
-)
 from starlette.requests import Request
 
 from nucliadb.common import datamanagers
 from nucliadb.common.cluster.settings import in_standalone_mode
 from nucliadb.common.context.fastapi import get_app_context
+from nucliadb.common.datamanagers.exceptions import KnowledgeBoxNotFound
 from nucliadb.common.http_clients import processing
 from nucliadb.common.maindb.utils import get_driver
+from nucliadb.common.models_utils import from_proto
 from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
 from nucliadb.models.responses import HTTPClientError
 from nucliadb.reader import SERVICE_NAME
@@ -53,13 +40,19 @@ from nucliadb.reader.api.v1.router import KB_PREFIX, api
 from nucliadb.reader.reader.notifications import kb_notifications_stream
 from nucliadb_models.entities import (
     EntitiesGroup,
-    EntitiesGroupSummary,
     KnowledgeBoxEntities,
 )
 from nucliadb_models.labels import KnowledgeBoxLabels, LabelSet
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.synonyms import KnowledgeBoxSynonyms
-from nucliadb_models.vectors import VectorSet, VectorSets
+from nucliadb_protos import writer_pb2
+from nucliadb_protos.knowledgebox_pb2 import Synonyms
+from nucliadb_protos.writer_pb2 import (
+    GetEntitiesGroupRequest,
+    GetEntitiesGroupResponse,
+    ListEntitiesGroupsRequest,
+    ListEntitiesGroupsResponse,
+)
 from nucliadb_utils.authentication import requires
 from nucliadb_utils.utilities import get_ingest, get_storage
 
@@ -67,7 +60,7 @@ from nucliadb_utils.utilities import get_ingest, get_storage
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/entitiesgroups",
     status_code=200,
-    name="Get Knowledge Box Entities",
+    summary="Get Knowledge Box Entities",
     response_model=KnowledgeBoxEntities,
     tags=["Knowledge Box Services"],
 )
@@ -93,25 +86,21 @@ async def list_entities_groups(kbid: str):
     if entities_groups.status == ListEntitiesGroupsResponse.Status.OK:
         response = KnowledgeBoxEntities(uuid=kbid)
         for key, eg_summary in entities_groups.groups.items():
-            entities_group = EntitiesGroupSummary.from_message(eg_summary)
+            entities_group = from_proto.entities_group_summary(eg_summary)
             response.groups[key] = entities_group
         return response
     elif entities_groups.status == ListEntitiesGroupsResponse.Status.NOTFOUND:
         raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
     elif entities_groups.status == ListEntitiesGroupsResponse.Status.ERROR:
-        raise HTTPException(
-            status_code=500, detail="Error while listing entities groups"
-        )
+        raise HTTPException(status_code=500, detail="Error while listing entities groups")
     else:
-        raise HTTPException(
-            status_code=500, detail="Error on listing Knowledge box entities"
-        )
+        raise HTTPException(status_code=500, detail="Error on listing Knowledge box entities")
 
 
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/entitiesgroup/{{group}}",
     status_code=200,
-    name="Get a Knowledge Box Entities Group",
+    summary="Get a Knowledge Box Entities Group",
     response_model=EntitiesGroup,
     tags=["Knowledge Box Services"],
 )
@@ -125,123 +114,90 @@ async def get_entity(request: Request, kbid: str, group: str) -> EntitiesGroup:
 
     kbobj: GetEntitiesGroupResponse = await ingest.GetEntitiesGroup(l_request)  # type: ignore
     if kbobj.status == GetEntitiesGroupResponse.Status.OK:
-        response = EntitiesGroup.from_message(kbobj.group)
+        response = from_proto.entities_group(kbobj.group)
         return response
     elif kbobj.status == GetEntitiesGroupResponse.Status.KB_NOT_FOUND:
-        raise HTTPException(
-            status_code=404, detail=f"Knowledge Box '{kbid}' does not exist"
-        )
+        raise HTTPException(status_code=404, detail=f"Knowledge Box '{kbid}' does not exist")
     elif kbobj.status == GetEntitiesGroupResponse.Status.ENTITIES_GROUP_NOT_FOUND:
-        raise HTTPException(
-            status_code=404, detail=f"Entities group '{group}' does not exist"
-        )
+        raise HTTPException(status_code=404, detail=f"Entities group '{group}' does not exist")
     else:
-        raise HTTPException(
-            status_code=500, detail="Error on getting entities group on a Knowledge box"
-        )
+        raise HTTPException(status_code=500, detail="Error on getting entities group on a Knowledge box")
 
 
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/labelsets",
     status_code=200,
-    name="Get Knowledge Box Label Sets",
+    summary="Get Knowledge Box Label Sets",
     response_model=KnowledgeBoxLabels,
     tags=["Knowledge Box Services"],
 )
 @requires(NucliaDBRoles.READER)
 @version(1)
-async def get_labelsets(request: Request, kbid: str) -> KnowledgeBoxLabels:
-    ingest = get_ingest()
-    l_request: GetLabelsRequest = GetLabelsRequest()
-    l_request.kb.uuid = kbid
+async def get_labelsets_endoint(request: Request, kbid: str) -> KnowledgeBoxLabels:
+    try:
+        return await get_labelsets(kbid)
+    except KnowledgeBoxNotFound:
+        raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
+
 
-    kbobj: GetLabelsResponse = await ingest.GetLabels(l_request)  # type: ignore
-    if kbobj.status == GetLabelsResponse.Status.OK:
-        response = KnowledgeBoxLabels(uuid=kbid)
-        for labelset, labelset_data in kbobj.labels.labelset.items():
-            labelset_response = LabelSet(
-                **MessageToDict(
-                    labelset_data,
-                    preserving_proto_field_name=True,
-                    including_default_value_fields=True,
-                )
+async def get_labelsets(kbid: str) -> KnowledgeBoxLabels:
+    kb_exists = await datamanagers.atomic.kb.exists_kb(kbid=kbid)
+    if not kb_exists:
+        raise KnowledgeBoxNotFound()
+    labelsets: writer_pb2.Labels = await datamanagers.atomic.labelset.get_all(kbid=kbid)
+    response = KnowledgeBoxLabels(uuid=kbid)
+    for labelset, labelset_data in labelsets.labelset.items():
+        labelset_response = LabelSet(
+            **MessageToDict(
+                labelset_data,
+                preserving_proto_field_name=True,
+                including_default_value_fields=True,
             )
-            response.labelsets[labelset] = labelset_response
-        return response
-    elif kbobj.status == GetLabelsResponse.Status.NOTFOUND:
-        raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
-    else:
-        raise HTTPException(
-            status_code=500, detail="Error on getting Knowledge box labels"
         )
+        response.labelsets[labelset] = labelset_response
+    return response
 
 
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/labelset/{{labelset}}",
     status_code=200,
-    name="Get a Knowledge Box Label Set",
+    summary="Get a Knowledge Box Label Set",
     response_model=LabelSet,
     tags=["Knowledge Box Services"],
 )
 @requires(NucliaDBRoles.READER)
 @version(1)
-async def get_labelset(request: Request, kbid: str, labelset: str) -> LabelSet:
-    ingest = get_ingest()
-    l_request: GetLabelSetRequest = GetLabelSetRequest()
-    l_request.kb.uuid = kbid
-    l_request.labelset = labelset
+async def get_labelset_endpoint(request: Request, kbid: str, labelset: str) -> LabelSet:
+    try:
+        return await get_labelset(kbid, labelset)
+    except KnowledgeBoxNotFound:
+        raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
 
-    kbobj: GetLabelSetResponse = await ingest.GetLabelSet(l_request)  # type: ignore
-    if kbobj.status == GetLabelSetResponse.Status.OK:
+
+async def get_labelset(kbid: str, labelset_id: str) -> LabelSet:
+    kb_exists = await datamanagers.atomic.kb.exists_kb(kbid=kbid)
+    if not kb_exists:
+        raise KnowledgeBoxNotFound()
+    labelset: Optional[writer_pb2.LabelSet] = await datamanagers.atomic.labelset.get(
+        kbid=kbid, labelset_id=labelset_id
+    )
+    if labelset is None:
+        response = LabelSet()
+    else:
         response = LabelSet(
             **MessageToDict(
-                kbobj.labelset,
+                labelset,
                 preserving_proto_field_name=True,
                 including_default_value_fields=True,
             )
         )
-        return response
-    elif kbobj.status == GetLabelSetResponse.Status.NOTFOUND:
-        raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
-    else:
-        raise HTTPException(
-            status_code=500, detail="Error on getting labelset on a Knowledge box"
-        )
-
-
-@api.get(
-    f"/{KB_PREFIX}/{{kbid}}/vectorsets",
-    status_code=200,
-    name="Get Knowledge Box Vector Sets",
-    tags=["Knowledge Box Services"],
-    response_model=VectorSets,
-    openapi_extra={"x-operation_order": 1},
-)
-@requires(NucliaDBRoles.READER)
-@version(1)
-async def get_vectorsets(request: Request, kbid: str):
-    ingest = get_ingest()
-    pbrequest: GetVectorSetsRequest = GetVectorSetsRequest()
-    pbrequest.kb.uuid = kbid
-
-    vectorsets: GetVectorSetsResponse = await ingest.GetVectorSets(pbrequest)  # type: ignore
-    if vectorsets.status == GetVectorSetsResponse.Status.OK:
-        result = VectorSets(vectorsets={})
-        for key, vector in vectorsets.vectorsets.vectorsets.items():
-            result.vectorsets[key] = VectorSet.from_message(vector)
-        return result
-    elif vectorsets.status == GetVectorSetsResponse.Status.NOTFOUND:
-        raise HTTPException(status_code=404, detail="VectorSet does not exist")
-    elif vectorsets.status == GetVectorSetsResponse.Status.ERROR:
-        raise HTTPException(
-            status_code=500, detail="Error on getting vectorset on a Knowledge box"
-        )
+    return response
 
 
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/custom-synonyms",
     status_code=200,
-    name="Get Knowledge Box Custom Synonyms",
+    summary="Get Knowledge Box Custom Synonyms",
     tags=["Knowledge Box Services"],
     response_model=KnowledgeBoxSynonyms,
     openapi_extra={"x-operation_order": 2},
@@ -249,23 +205,16 @@ async def get_vectorsets(request: Request, kbid: str):
 @requires(NucliaDBRoles.READER)
 @version(1)
 async def get_custom_synonyms(request: Request, kbid: str):
-    ingest = get_ingest()
-    pbrequest = KnowledgeBoxID(uuid=kbid)
-    pbresponse: GetSynonymsResponse = await ingest.GetSynonyms(pbrequest)  # type: ignore
-    if pbresponse.status.status == OpStatusWriter.Status.OK:
-        return KnowledgeBoxSynonyms.from_message(pbresponse.synonyms)
-    elif pbresponse.status.status == OpStatusWriter.Status.NOTFOUND:
+    if not await datamanagers.atomic.kb.exists_kb(kbid=kbid):
         raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
-    elif pbresponse.status.status == OpStatusWriter.Status.ERROR:
-        raise HTTPException(
-            status_code=500, detail="Error getting synonyms of a Knowledge box"
-        )
+    synonyms = await datamanagers.atomic.synonyms.get(kbid=kbid) or Synonyms()
+    return from_proto.kb_synonyms(synonyms)
 
 
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/notifications",
     status_code=200,
-    name="Knowledge Box Notifications Stream",
+    summary="Knowledge Box Notifications Stream",
     description="Provides a stream of activity notifications for the given Knowledge Box. The stream will be automatically closed after 2 minutes.",  # noqa: E501
     tags=["Knowledge Box Services"],
     response_description="Each line of the response is a Base64-encoded JSON object representing a notification. Refer to [the internal documentation](https://github.com/nuclia/nucliadb/blob/main/docs/tutorials/KB_NOTIFICATIONS.md) for a more detailed explanation of each notification type.",  # noqa: E501
@@ -298,14 +247,14 @@ async def notifications_endpoint(
 
 
 async def exists_kb(kbid: str) -> bool:
-    async with datamanagers.with_transaction(read_only=True) as txn:
+    async with datamanagers.with_ro_transaction() as txn:
         return await datamanagers.kb.exists_kb(txn, kbid=kbid)
 
 
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/processing-status",
     status_code=200,
-    name="Knowledge Box Processing Status",
+    summary="Knowledge Box Processing Status",
     description="Provides the status of the processing of the given Knowledge Box.",
     tags=["Knowledge Box Services"],
     response_model=processing.RequestsResults,
@@ -326,14 +275,12 @@ async def processing_status(
         return HTTPClientError(status_code=404, detail="Knowledge Box not found")
 
     async with processing.ProcessingHTTPClient() as client:
-        results = await client.requests(
-            cursor=cursor, scheduled=scheduled, kbid=kbid, limit=limit
-        )
+        results = await client.requests(cursor=cursor, scheduled=scheduled, kbid=kbid, limit=limit)
 
     storage = await get_storage(service_name=SERVICE_NAME)
     driver = get_driver()
 
-    async with driver.transaction(wait_for_abort=False, read_only=True) as txn:
+    async with driver.transaction(read_only=True) as txn:
         kb = KnowledgeBox(txn, storage, kbid)
 
         max_simultaneous = asyncio.Semaphore(10)
@@ -355,9 +302,7 @@ async def processing_status(
 
         result_items = [
             item
-            for item in await asyncio.gather(
-                *[_composition(result) for result in results.results]
-            )
+            for item in await asyncio.gather(*[_composition(result) for result in results.results])
             if item is not None
         ]