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

nucliadb/ingest/orm/knowledgebox.py

@@ -17,9 +17,10 @@
 # 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 collections.abc import AsyncGenerator, Callable, Coroutine, Sequence
 from datetime import datetime
 from functools import partial
-from typing import Any, AsyncGenerator, Callable, Coroutine, Optional, Sequence
+from typing import Any
 from uuid import uuid4
 
 from grpc import StatusCode
@@ -88,7 +89,7 @@ class KnowledgeBox:
         self.txn = txn
         self.storage = storage
         self.kbid = kbid
-        self._config: Optional[KnowledgeBoxConfig] = None
+        self._config: KnowledgeBoxConfig | None = None
 
     @staticmethod
     def new_unique_kbid() -> str:
@@ -248,14 +249,14 @@ class KnowledgeBox:
         driver: Driver,
         kbid: str,
         *,
-        slug: Optional[str] = None,
-        title: Optional[str] = None,
-        description: Optional[str] = None,
-        migration_version: Optional[int] = None,
-        external_index_provider: Optional[StoredExternalIndexProviderMetadata] = None,
-        hidden_resources_enabled: Optional[bool] = None,
-        hidden_resources_hide_on_creation: Optional[bool] = None,
-        prewarm_enabled: Optional[bool] = None,
+        slug: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        migration_version: int | None = None,
+        external_index_provider: StoredExternalIndexProviderMetadata | None = None,
+        hidden_resources_enabled: bool | None = None,
+        hidden_resources_hide_on_creation: bool | None = None,
+        prewarm_enabled: bool | None = None,
     ) -> str:
         async with driver.rw_transaction() as txn:
             stored = await datamanagers.kb.get_config(txn, kbid=kbid, for_update=True)
@@ -428,7 +429,7 @@ class KnowledgeBox:
             await txn.delete_by_prefix(prefix)
             await txn.commit()
 
-    async def get_resource_shard(self, shard_id: str) -> Optional[writer_pb2.ShardObject]:
+    async def get_resource_shard(self, shard_id: str) -> writer_pb2.ShardObject | None:
         async with datamanagers.with_ro_transaction() as txn:
             pb = await datamanagers.cluster.get_kb_shards(txn, kbid=self.kbid)
             if pb is None:
@@ -439,18 +440,8 @@ class KnowledgeBox:
                 return shard
         return None
 
-    async def get(self, uuid: str) -> Optional[Resource]:
-        basic = await datamanagers.resources.get_basic(self.txn, kbid=self.kbid, rid=uuid)
-        if basic is None:
-            return None
-        return Resource(
-            txn=self.txn,
-            storage=self.storage,
-            kb=self,
-            uuid=uuid,
-            basic=basic,
-            disable_vectors=False,
-        )
+    async def get(self, uuid: str) -> Resource | None:
+        return await Resource.get(self.txn, self.kbid, uuid)
 
     async def maindb_delete_resource(self, uuid: str):
         basic = await datamanagers.resources.get_basic(self.txn, kbid=self.kbid, rid=uuid)
@@ -479,7 +470,7 @@ class KnowledgeBox:
         with processor_observer({"type": "delete_resource_storage"}):
             await self.storage_delete_resource(uuid)
 
-    async def get_resource_uuid_by_slug(self, slug: str) -> Optional[str]:
+    async def get_resource_uuid_by_slug(self, slug: str) -> str | None:
         return await datamanagers.resources.get_resource_uuid_from_slug(
             self.txn, kbid=self.kbid, slug=slug
         )
@@ -496,7 +487,7 @@ class KnowledgeBox:
                 key_ok = True
         return slug
 
-    async def add_resource(self, uuid: str, slug: str, basic: Optional[Basic] = None) -> Resource:
+    async def add_resource(self, uuid: str, slug: str, basic: Basic | None = None) -> Resource:
         if basic is None:
             basic = Basic()
         if slug == "":
@@ -508,7 +499,7 @@ class KnowledgeBox:
         return Resource(
             storage=self.storage,
             txn=self.txn,
-            kb=self,
+            kbid=self.kbid,
             uuid=uuid,
             basic=basic,
             disable_vectors=False,
@@ -523,7 +514,7 @@ class KnowledgeBox:
                 yield Resource(
                     self.txn,
                     self.storage,
-                    self,
+                    self.kbid,
                     uuid,
                     disable_vectors=False,
                 )

nucliadb/ingest/orm/processor/auditing.py

@@ -18,7 +18,6 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 from nucliadb.common.maindb.driver import Driver
-from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
 from nucliadb.ingest.orm.resource import Resource
 from nucliadb_protos import audit_pb2, writer_pb2
 from nucliadb_protos.resources_pb2 import FieldType
@@ -35,8 +34,7 @@ async def collect_audit_fields(
 
     audit_storage_fields: list[audit_pb2.AuditField] = []
     async with driver.ro_transaction() as txn:
-        kb = KnowledgeBox(txn, storage, message.kbid)
-        resource = Resource(txn, storage, kb, message.uuid)
+        resource = Resource(txn, storage, message.kbid, message.uuid)
         field_keys = await resource.get_fields_ids()
 
         for field_id, field_type in iterate_auditable_fields(field_keys, message):

nucliadb/ingest/orm/processor/data_augmentation.py

@@ -20,7 +20,6 @@
 
 import logging
 from dataclasses import dataclass, field
-from typing import Optional
 
 from nucliadb.ingest.orm.resource import Resource
 from nucliadb.ingest.processing import ProcessingEngine
@@ -94,7 +93,7 @@ def _generate_processing_payload_for_fields(
     rid: str,
     fields: GeneratedFields,
     bm: writer_pb2.BrokerMessage,
-) -> Optional[PushPayload]:
+) -> PushPayload | None:
     partitioning = get_partitioning()
     partition = partitioning.generate_partition(kbid, rid)
 

nucliadb/ingest/orm/processor/processor.py

@@ -19,7 +19,6 @@
 #
 import asyncio
 import logging
-from typing import Optional
 
 import aiohttp.client_exceptions
 import nats.errors
@@ -145,8 +144,8 @@ class Processor:
         self,
         driver: Driver,
         storage: Storage,
-        pubsub: Optional[PubSubDriver] = None,
-        partition: Optional[str] = None,
+        pubsub: PubSubDriver | None = None,
+        partition: str | None = None,
     ):
         self.driver = driver
         self.storage = storage
@@ -158,7 +157,7 @@ class Processor:
         self,
         message: writer_pb2.BrokerMessage,
         seqid: int,
-        partition: Optional[str] = None,
+        partition: str | None = None,
         transaction_check: bool = True,
     ) -> None:
         partition = partition if self.partition is None else self.partition
@@ -285,7 +284,7 @@ class Processor:
                 kb = KnowledgeBox(txn, self.storage, kbid)
                 uuid = await self.get_resource_uuid(kb, message)
 
-                resource: Optional[Resource] = None
+                resource: Resource | None = None
                 handled_exception = None
                 created = False
 
@@ -446,26 +445,27 @@ class Processor:
             # a resource was move to another shard while it was being indexed
             shard_id = await datamanagers.resources.get_resource_shard_id(txn, kbid=kbid, rid=uuid)
 
-        shard = None
-        if shard_id is not None:
-            # Resource already has a shard assigned
-            shard = await kb.get_resource_shard(shard_id)
-            if shard is None:
-                raise AttributeError("Shard not available")
-        else:
-            # It's a new resource, get KB's current active shard to place new resource on
-            shard = await self.index_node_shard_manager.get_current_active_shard(txn, kbid)
-            if shard is None:
-                # No current shard available, create a new one
-                kb_config = await datamanagers.kb.get_config(txn, kbid=kbid)
-                prewarm = kb_config is not None and kb_config.prewarm_enabled
-                shard = await self.index_node_shard_manager.create_shard_by_kbid(
-                    txn, kbid, prewarm_enabled=prewarm
+            shard = None
+            if shard_id is not None:
+                # Resource already has a shard assigned
+                shard = await kb.get_resource_shard(shard_id)
+                if shard is None:
+                    raise AttributeError("Shard not available")
+            else:
+                # It's a new resource, get KB's current active shard to place new resource on
+                shard = await self.index_node_shard_manager.get_current_active_shard(txn, kbid)
+                if shard is None:
+                    # No current shard available, create a new one
+                    async with locking.distributed_lock(locking.NEW_SHARD_LOCK.format(kbid=kbid)):
+                        kb_config = await datamanagers.kb.get_config(txn, kbid=kbid)
+                        prewarm = kb_config is not None and kb_config.prewarm_enabled
+                        shard = await self.index_node_shard_manager.create_shard_by_kbid(
+                            txn, kbid, prewarm_enabled=prewarm
+                        )
+                await datamanagers.resources.set_resource_shard_id(
+                    txn, kbid=kbid, rid=uuid, shard=shard.shard
                 )
-            await datamanagers.resources.set_resource_shard_id(
-                txn, kbid=kbid, rid=uuid, shard=shard.shard
-            )
-        return shard
+            return shard
 
     @processor_observer.wrap({"type": "index_resource"})
     async def index_resource(
@@ -674,7 +674,7 @@ class Processor:
             await self.pubsub.publish(channel, payload)
 
     async def _mark_resource_error(
-        self, kb: KnowledgeBox, resource: Optional[Resource], partition: str, seqid: int
+        self, kb: KnowledgeBox, resource: Resource | None, partition: str, seqid: int
     ) -> None:
         """
         Unhandled error processing, try to mark resource as error
@@ -695,8 +695,8 @@ class Processor:
     # XXX: Why are these utility functions here?
     async def get_kb_obj(
         self, txn: Transaction, kbid: knowledgebox_pb2.KnowledgeBoxID
-    ) -> Optional[KnowledgeBox]:
-        uuid: Optional[str] = kbid.uuid
+    ) -> KnowledgeBox | None:
+        uuid: str | None = kbid.uuid
         if uuid == "":
             uuid = await datamanagers.kb.get_kb_uuid(txn, slug=kbid.slug)
 

nucliadb/ingest/orm/processor/sequence_manager.py

@@ -17,14 +17,13 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
-from typing import Optional
 
 from nucliadb.common.maindb.driver import Driver, Transaction
 
 TXNID = "/internal/worker/{worker}"
 
 
-async def get_last_seqid(driver: Driver, worker: str) -> Optional[int]:
+async def get_last_seqid(driver: Driver, worker: str) -> int | None:
     """
     Get last stored sequence id for a worker.
 

nucliadb/ingest/orm/resource.py

@@ -22,8 +22,9 @@ from __future__ import annotations
 import asyncio
 import logging
 from collections import defaultdict
+from collections.abc import Sequence
 from concurrent.futures import ThreadPoolExecutor
-from typing import TYPE_CHECKING, Any, Optional, Sequence, Type
+from typing import Any
 
 from nucliadb.common import datamanagers
 from nucliadb.common.datamanagers.resources import KB_RESOURCE_SLUG
@@ -68,13 +69,11 @@ from nucliadb_protos.resources_pb2 import Origin as PBOrigin
 from nucliadb_protos.resources_pb2 import Relations as PBRelations
 from nucliadb_protos.writer_pb2 import BrokerMessage
 from nucliadb_utils.storages.storage import Storage
-
-if TYPE_CHECKING:  # pragma: no cover
-    from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
+from nucliadb_utils.utilities import get_storage
 
 logger = logging.getLogger(__name__)
 
-KB_FIELDS: dict[int, Type] = {
+KB_FIELDS: dict[int, type] = {
     FieldType.TEXT: Text,
     FieldType.FILE: File,
     FieldType.LINK: Link,
@@ -104,40 +103,55 @@ class Resource:
         self,
         txn: Transaction,
         storage: Storage,
-        kb: KnowledgeBox,
+        kbid: str,
         uuid: str,
-        basic: Optional[PBBasic] = None,
+        basic: PBBasic | None = None,
         disable_vectors: bool = True,
     ):
         self.fields: dict[tuple[FieldType.ValueType, str], Field] = {}
         self.conversations: dict[int, PBConversation] = {}
-        self.relations: Optional[PBRelations] = None
-        self.all_fields_keys: Optional[list[tuple[FieldType.ValueType, str]]] = None
-        self.origin: Optional[PBOrigin] = None
-        self.extra: Optional[PBExtra] = None
-        self.security: Optional[utils_pb2.Security] = None
+        self.relations: PBRelations | None = None
+        self.all_fields_keys: list[tuple[FieldType.ValueType, str]] | None = None
+        self.origin: PBOrigin | None = None
+        self.extra: PBExtra | None = None
+        self.security: utils_pb2.Security | None = None
         self.modified: bool = False
         self._modified_extracted_text: list[FieldID] = []
 
         self.txn = txn
         self.storage = storage
-        self.kb = kb
+        self.kbid = kbid
         self.uuid = uuid
         self.basic = basic
         self.disable_vectors = disable_vectors
-        self._previous_status: Optional[Metadata.Status.ValueType] = None
-        self.user_relations: Optional[PBRelations] = None
+        self._previous_status: Metadata.Status.ValueType | None = None
+        self.user_relations: PBRelations | None = None
         self.locks: dict[str, asyncio.Lock] = defaultdict(asyncio.Lock)
 
+    @classmethod
+    async def get(cls, txn: Transaction, kbid: str, rid: str) -> Resource | None:
+        basic = await datamanagers.resources.get_basic(txn, kbid=kbid, rid=rid)
+        if basic is None:
+            return None
+        storage = await get_storage()
+        return cls(
+            txn=txn,
+            storage=storage,
+            kbid=kbid,
+            uuid=rid,
+            basic=basic,
+            disable_vectors=False,
+        )
+
     async def set_slug(self):
         basic = await self.get_basic()
-        new_key = KB_RESOURCE_SLUG.format(kbid=self.kb.kbid, slug=basic.slug)
+        new_key = KB_RESOURCE_SLUG.format(kbid=self.kbid, slug=basic.slug)
         await self.txn.set(new_key, self.uuid.encode())
 
     # Basic
     async def get_basic(self) -> PBBasic:
         if self.basic is None:
-            basic = await datamanagers.resources.get_basic(self.txn, kbid=self.kb.kbid, rid=self.uuid)
+            basic = await datamanagers.resources.get_basic(self.txn, kbid=self.kbid, rid=self.uuid)
             self.basic = basic if basic is not None else PBBasic()
         return self.basic
 
@@ -159,7 +173,7 @@ class Resource:
     async def set_basic(
         self,
         payload: PBBasic,
-        deleted_fields: Optional[list[FieldID]] = None,
+        deleted_fields: list[FieldID] | None = None,
     ):
         await self.get_basic()
 
@@ -212,49 +226,43 @@ class Resource:
         if deleted_fields is not None and len(deleted_fields) > 0:
             delete_basic_computedmetadata_classifications(self.basic, deleted_fields=deleted_fields)
 
-        await datamanagers.resources.set_basic(
-            self.txn, kbid=self.kb.kbid, rid=self.uuid, basic=self.basic
-        )
+        await datamanagers.resources.set_basic(self.txn, kbid=self.kbid, rid=self.uuid, basic=self.basic)
         self.modified = True
 
     # Origin
-    async def get_origin(self) -> Optional[PBOrigin]:
+    async def get_origin(self) -> PBOrigin | None:
         if self.origin is None:
-            origin = await datamanagers.resources.get_origin(self.txn, kbid=self.kb.kbid, rid=self.uuid)
+            origin = await datamanagers.resources.get_origin(self.txn, kbid=self.kbid, rid=self.uuid)
             self.origin = origin
         return self.origin
 
     async def set_origin(self, payload: PBOrigin):
-        await datamanagers.resources.set_origin(
-            self.txn, kbid=self.kb.kbid, rid=self.uuid, origin=payload
-        )
+        await datamanagers.resources.set_origin(self.txn, kbid=self.kbid, rid=self.uuid, origin=payload)
         self.modified = True
         self.origin = payload
 
     # Extra
-    async def get_extra(self) -> Optional[PBExtra]:
+    async def get_extra(self) -> PBExtra | None:
         if self.extra is None:
-            extra = await datamanagers.resources.get_extra(self.txn, kbid=self.kb.kbid, rid=self.uuid)
+            extra = await datamanagers.resources.get_extra(self.txn, kbid=self.kbid, rid=self.uuid)
             self.extra = extra
         return self.extra
 
     async def set_extra(self, payload: PBExtra):
-        await datamanagers.resources.set_extra(self.txn, kbid=self.kb.kbid, rid=self.uuid, extra=payload)
+        await datamanagers.resources.set_extra(self.txn, kbid=self.kbid, rid=self.uuid, extra=payload)
         self.modified = True
         self.extra = payload
 
     # Security
-    async def get_security(self) -> Optional[utils_pb2.Security]:
+    async def get_security(self) -> utils_pb2.Security | None:
         if self.security is None:
-            security = await datamanagers.resources.get_security(
-                self.txn, kbid=self.kb.kbid, rid=self.uuid
-            )
+            security = await datamanagers.resources.get_security(self.txn, kbid=self.kbid, rid=self.uuid)
             self.security = security
         return self.security
 
     async def set_security(self, payload: utils_pb2.Security) -> None:
         await datamanagers.resources.set_security(
-            self.txn, kbid=self.kb.kbid, rid=self.uuid, security=payload
+            self.txn, kbid=self.kbid, rid=self.uuid, security=payload
         )
         self.modified = True
         self.security = payload
@@ -262,7 +270,7 @@ class Resource:
     # Relations
     async def get_user_relations(self) -> PBRelations:
         if self.user_relations is None:
-            sf = self.storage.user_relations(self.kb.kbid, self.uuid)
+            sf = self.storage.user_relations(self.kbid, self.uuid)
             relations = await self.storage.download_pb(sf, PBRelations)
             if relations is None:
                 # Key not found = no relations
@@ -272,7 +280,7 @@ class Resource:
         return self.user_relations
 
     async def set_user_relations(self, payload: PBRelations):
-        sf = self.storage.user_relations(self.kb.kbid, self.uuid)
+        sf = self.storage.user_relations(self.kbid, self.uuid)
         await self.storage.upload_pb(sf, payload)
         self.modified = True
         self.user_relations = payload
@@ -366,22 +374,22 @@ class Resource:
         # REVIEW: are we sure we don't want to actually check this?
         return (type, field) in self.fields
 
-    async def get_all_field_ids(self, *, for_update: bool) -> Optional[PBAllFieldIDs]:
+    async def get_all_field_ids(self, *, for_update: bool) -> PBAllFieldIDs | None:
         return await datamanagers.resources.get_all_field_ids(
-            self.txn, kbid=self.kb.kbid, rid=self.uuid, for_update=for_update
+            self.txn, kbid=self.kbid, rid=self.uuid, for_update=for_update
         )
 
     async def set_all_field_ids(self, all_fields: PBAllFieldIDs):
         return await datamanagers.resources.set_all_field_ids(
-            self.txn, kbid=self.kb.kbid, rid=self.uuid, allfields=all_fields
+            self.txn, kbid=self.kbid, rid=self.uuid, allfields=all_fields
         )
 
     async def update_all_field_ids(
         self,
         *,
-        updated: Optional[list[FieldID]] = None,
-        deleted: Optional[list[FieldID]] = None,
-        errors: Optional[list[writer_pb2.Error]] = None,
+        updated: list[FieldID] | None = None,
+        deleted: list[FieldID] | None = None,
+        errors: list[writer_pb2.Error] | None = None,
     ):
         needs_update = False
         all_fields = await self.get_all_field_ids(for_update=True)
@@ -460,7 +468,7 @@ class Resource:
 
         # If this message comes from the processor (not a DA worker), we clear all previous errors
         # TODO: When generated_by is populated with DA tasks by processor, remove only related errors
-        from_processor = any((x.WhichOneof("generator") == "processor" for x in message.generated_by))
+        from_processor = any(x.WhichOneof("generator") == "processor" for x in message.generated_by)
 
         for (field_type, field), errors in errors_by_field.items():
             field_obj = await self.get_field(field, field_type, load=False)
@@ -480,7 +488,7 @@ class Resource:
             # We infer the status for processor messages
             if message.source == BrokerMessage.MessageSource.PROCESSOR:
                 if any(
-                    (e.source_error.severity == writer_pb2.Error.Severity.ERROR for e in status.errors)
+                    e.source_error.severity == writer_pb2.Error.Severity.ERROR for e in status.errors
                 ):
                     status.status = writer_pb2.FieldStatus.Status.ERROR
                 else:
@@ -510,25 +518,21 @@ class Resource:
             return
 
         field_statuses = await datamanagers.fields.get_statuses(
-            self.txn, kbid=self.kb.kbid, rid=self.uuid, fields=field_ids.fields
+            self.txn, kbid=self.kbid, rid=self.uuid, fields=field_ids.fields
         )
 
         # If any field is processing -> PENDING
-        if any((f.status == writer_pb2.FieldStatus.Status.PENDING for f in field_statuses)):
+        if any(f.status == writer_pb2.FieldStatus.Status.PENDING for f in field_statuses):
             self.basic.metadata.status = PBMetadata.Status.PENDING
         # If we have any non-DA error -> ERROR
         elif any(
-            (
-                f.status == writer_pb2.FieldStatus.Status.ERROR
-                and any(
-                    (
-                        e.source_error.severity == writer_pb2.Error.Severity.ERROR
-                        and e.source_error.code != writer_pb2.Error.ErrorCode.DATAAUGMENTATION
-                        for e in f.errors
-                    )
-                )
-                for f in field_statuses
+            f.status == writer_pb2.FieldStatus.Status.ERROR
+            and any(
+                e.source_error.severity == writer_pb2.Error.Severity.ERROR
+                and e.source_error.code != writer_pb2.Error.ErrorCode.DATAAUGMENTATION
+                for e in f.errors
             )
+            for f in field_statuses
         ):
             self.basic.metadata.status = PBMetadata.Status.ERROR
         # Otherwise (everything processed or we only have DA errors) -> PROCESSED
@@ -651,7 +655,7 @@ class Resource:
             FieldType.LINK,
             load=False,
         )
-        maybe_update_basic_thumbnail(self.basic, link_extracted_data.link_thumbnail, self.kb.kbid)
+        maybe_update_basic_thumbnail(self.basic, link_extracted_data.link_thumbnail, self.kbid)
 
         await field_link.set_link_extracted_data(link_extracted_data)
 
@@ -678,7 +682,7 @@ class Resource:
             return
         logger.info(
             "Updating resource title from link extracted data",
-            extra={"kbid": self.kb.kbid, "field": link_extracted_data.field, "rid": self.uuid},
+            extra={"kbid": self.kbid, "field": link_extracted_data.field, "rid": self.uuid},
         )
         title = link_extracted_data.title
         await self.update_resource_title(title)
@@ -720,7 +724,7 @@ class Resource:
         # uri can change after extraction
         await field_file.set_file_extracted_data(file_extracted_data)
         maybe_update_basic_icon(self.basic, file_extracted_data.icon)
-        maybe_update_basic_thumbnail(self.basic, file_extracted_data.file_thumbnail, self.kb.kbid)
+        maybe_update_basic_thumbnail(self.basic, file_extracted_data.file_thumbnail, self.kbid)
         self.modified = True
 
     async def _should_update_resource_title_from_file_metadata(self) -> bool:
@@ -742,7 +746,7 @@ class Resource:
         filenames = set()
         for (field_type, _), field_obj in fields.items():
             if field_type == FieldType.FILE:
-                field_value: Optional[FieldFile] = await field_obj.get_value()
+                field_value: FieldFile | None = await field_obj.get_value()
                 if field_value is not None:
                     if field_value.file.filename not in ("", None):
                         filenames.add(field_value.file.filename)
@@ -767,7 +771,7 @@ class Resource:
             fid = FieldId.from_pb(rid=self.uuid, field_type=FieldType.FILE, key=fed.field)
             logger.info(
                 "Updating resource title from file extracted data",
-                extra={"kbid": self.kb.kbid, "field": fid.full(), "new_title": fed.title},
+                extra={"kbid": self.kbid, "field": fid.full(), "new_title": fed.title},
             )
             await self.update_resource_title(fed.title)
             await self.unmark_title_for_reset()
@@ -785,9 +789,7 @@ class Resource:
         )
         await field_obj.set_field_metadata(field_metadata)
 
-        maybe_update_basic_thumbnail(
-            self.basic, field_metadata.metadata.metadata.thumbnail, self.kb.kbid
-        )
+        maybe_update_basic_thumbnail(self.basic, field_metadata.metadata.metadata.thumbnail, self.kbid)
 
         update_basic_computedmetadata_classifications(self.basic, field_metadata)
         self.modified = True
@@ -799,7 +801,7 @@ class Resource:
         await self.get_fields(force=True)
         vectorsets = {
             vectorset_id: vs
-            async for vectorset_id, vs in datamanagers.vectorsets.iter(self.txn, kbid=self.kb.kbid)
+            async for vectorset_id, vs in datamanagers.vectorsets.iter(self.txn, kbid=self.kbid)
         }
 
         for field_vectors in fields_vectors:
@@ -808,13 +810,13 @@ class Resource:
                 assert len(vectorsets) == 1, (
                     "Invalid broker message, can't ingest vectors from unknown vectorset to KB with multiple vectorsets"
                 )
-                vectorset = list(vectorsets.values())[0]
+                vectorset = next(iter(vectorsets.values()))
 
             else:
                 if field_vectors.vectorset_id not in vectorsets:
                     logger.warning(
                         "Dropping extracted vectors for unknown vectorset",
-                        extra={"kbid": self.kb.kbid, "vectorset": field_vectors.vectorset_id},
+                        extra={"kbid": self.kbid, "vectorset": field_vectors.vectorset_id},
                     )
                     continue
 
@@ -925,7 +927,7 @@ def maybe_update_basic_summary(basic: PBBasic, summary_text: str) -> bool:
     return True
 
 
-def maybe_update_basic_icon(basic: PBBasic, mimetype: Optional[str]) -> bool:
+def maybe_update_basic_icon(basic: PBBasic, mimetype: str | None) -> bool:
     if basic.icon not in (None, "", "application/octet-stream", GENERIC_MIME_TYPE):
         # Icon already set or detected
         return False
@@ -944,7 +946,7 @@ def maybe_update_basic_icon(basic: PBBasic, mimetype: Optional[str]) -> bool:
     return True
 
 
-def maybe_update_basic_thumbnail(basic: PBBasic, thumbnail: Optional[CloudFile], kbid: str) -> bool:
+def maybe_update_basic_thumbnail(basic: PBBasic, thumbnail: CloudFile | None, kbid: str) -> bool:
     if basic.thumbnail or thumbnail is None:
         return False
     basic.thumbnail = CloudLink.format_reader_download_uri(thumbnail.uri)
@@ -981,7 +983,7 @@ def update_basic_languages(basic: Basic, languages: list[str]) -> bool:
     return updated
 
 
-def get_text_field_mimetype(bm: BrokerMessage) -> Optional[str]:
+def get_text_field_mimetype(bm: BrokerMessage) -> str | None:
     if len(bm.texts) == 0:
         return None
     text_format = next(iter(bm.texts.values())).format

nucliadb/ingest/orm/utils.py

@@ -18,7 +18,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 import urllib.parse
-from typing import Sequence
+from collections.abc import Sequence
 
 from nucliadb.models.internal.processing import PushPayload, PushTextFormat, Text
 from nucliadb_protos.resources_pb2 import (