nucliadb 6.2.0.post2675__py3-none-any.whl → 6.2.1__py3-none-any.whl

nucliadb/train/generators/field_streaming.py

@@ -97,9 +97,13 @@ async def generate_field_streaming_payloads(
         tl.field = field
         tl.field_type = field_type
         tl.split = split
-        extracted = await get_field_text(kbid, rid, field, field_type)
-        if extracted is not None:
-            tl.text.CopyFrom(extracted)
+
+        if trainset.exclude_text:
+            tl.text.text = ""
+        else:
+            extracted = await get_field_text(kbid, rid, field, field_type)
+            if extracted is not None:
+                tl.text.CopyFrom(extracted)
 
         metadata_obj = await get_field_metadata(kbid, rid, field, field_type)
         if metadata_obj is not None:

nucliadb/train/lifecycle.py

@@ -22,10 +22,7 @@ from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 
-from nucliadb.common.cluster.discovery.utils import (
-    setup_cluster_discovery,
-    teardown_cluster_discovery,
-)
+from nucliadb.common.nidx import start_nidx_utility, stop_nidx_utility
 from nucliadb.train import SERVICE_NAME
 from nucliadb.train.utils import (
     start_shard_manager,
@@ -40,7 +37,7 @@ from nucliadb_utils.utilities import start_audit_utility, stop_audit_utility
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     await setup_telemetry(SERVICE_NAME)
-    await setup_cluster_discovery()
+    await start_nidx_utility()
     await start_shard_manager()
     await start_train_grpc(SERVICE_NAME)
     await start_audit_utility(SERVICE_NAME)
@@ -50,5 +47,5 @@ async def lifespan(app: FastAPI):
     await stop_audit_utility()
     await stop_train_grpc()
     await stop_shard_manager()
-    await teardown_cluster_discovery()
+    await stop_nidx_utility()
     await clean_telemetry(SERVICE_NAME)

nucliadb/train/nodes.py

@@ -28,6 +28,12 @@ from nucliadb.common.datamanagers.resources import KB_RESOURCE_SLUG_BASE
 from nucliadb.common.maindb.driver import Driver, Transaction
 from nucliadb.ingest.orm.entities import EntitiesManager
 from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
+from nucliadb.train.resource import (
+    generate_train_resource,
+    iterate_fields,
+    iterate_paragraphs,
+    iterate_sentences,
+)
 from nucliadb_protos.train_pb2 import (
     GetFieldsRequest,
     GetParagraphsRequest,
@@ -39,9 +45,7 @@ from nucliadb_protos.train_pb2 import (
     TrainSentence,
 )
 from nucliadb_protos.writer_pb2 import ShardObject
-from nucliadb_utils import const
 from nucliadb_utils.storages.storage import Storage
-from nucliadb_utils.utilities import has_feature
 
 
 class TrainShardManager(manager.KBShardManager):
@@ -57,9 +61,7 @@ class TrainShardManager(manager.KBShardManager):
         except StopIteration:
             raise KeyError("Shard not found")
 
-        node_obj, shard_id = manager.choose_node(
-            shard_object, use_nidx=has_feature(const.Features.NIDX_READS, context={"kbid": kbid})
-        )
+        node_obj, shard_id = manager.choose_node(shard_object)
         return node_obj, shard_id
 
     async def get_kb_obj(self, txn: Transaction, kbid: str) -> Optional[KnowledgeBox]:
@@ -87,11 +89,11 @@ class TrainShardManager(manager.KBShardManager):
                 # Filter by uuid
                 resource = await kb.get(request.uuid)
                 if resource:
-                    async for sentence in resource.iterate_sentences(request.metadata):
+                    async for sentence in iterate_sentences(resource, request.metadata):
                         yield sentence
             else:
                 async for resource in kb.iterate_resources():
-                    async for sentence in resource.iterate_sentences(request.metadata):
+                    async for sentence in iterate_sentences(resource, request.metadata):
                         yield sentence
 
     async def kb_paragraphs(self, request: GetParagraphsRequest) -> AsyncIterator[TrainParagraph]:
@@ -101,11 +103,11 @@ class TrainShardManager(manager.KBShardManager):
                 # Filter by uuid
                 resource = await kb.get(request.uuid)
                 if resource:
-                    async for paragraph in resource.iterate_paragraphs(request.metadata):
+                    async for paragraph in iterate_paragraphs(resource, request.metadata):
                         yield paragraph
             else:
                 async for resource in kb.iterate_resources():
-                    async for paragraph in resource.iterate_paragraphs(request.metadata):
+                    async for paragraph in iterate_paragraphs(resource, request.metadata):
                         yield paragraph
 
     async def kb_fields(self, request: GetFieldsRequest) -> AsyncIterator[TrainField]:
@@ -115,11 +117,11 @@ class TrainShardManager(manager.KBShardManager):
                 # Filter by uuid
                 resource = await kb.get(request.uuid)
                 if resource:
-                    async for field in resource.iterate_fields(request.metadata):
+                    async for field in iterate_fields(resource, request.metadata):
                         yield field
             else:
                 async for resource in kb.iterate_resources():
-                    async for field in resource.iterate_fields(request.metadata):
+                    async for field in iterate_fields(resource, request.metadata):
                         yield field
 
     async def kb_resources(self, request: GetResourcesRequest) -> AsyncIterator[TrainResource]:
@@ -132,4 +134,4 @@ class TrainShardManager(manager.KBShardManager):
                 if rid is not None:
                     resource = await kb.get(rid.decode())
                     if resource is not None:
-                        yield await resource.generate_train_resource(request.metadata)
+                        yield await generate_train_resource(resource, request.metadata)

nucliadb/train/resource.py

@@ -0,0 +1,380 @@
+# 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/>.
+#
+from __future__ import annotations
+
+from typing import AsyncIterator, MutableMapping, Optional
+
+from nucliadb.common import datamanagers
+from nucliadb.ingest.orm.resource import Resource
+from nucliadb_protos.resources_pb2 import (
+    FieldID,
+    FieldMetadata,
+    ParagraphAnnotation,
+)
+from nucliadb_protos.train_pb2 import (
+    EnabledMetadata,
+    TrainField,
+    TrainMetadata,
+    TrainParagraph,
+    TrainResource,
+    TrainSentence,
+)
+from nucliadb_protos.train_pb2 import Position as TrainPosition
+
+
+async def iterate_sentences(
+    resource: Resource,
+    enabled_metadata: EnabledMetadata,
+) -> AsyncIterator[TrainSentence]:  # pragma: no cover
+    fields = await resource.get_fields(force=True)
+    metadata = TrainMetadata()
+    userdefinedparagraphclass: dict[str, ParagraphAnnotation] = {}
+    if enabled_metadata.labels:
+        if resource.basic is None:
+            resource.basic = await resource.get_basic()
+        if resource.basic is not None:
+            metadata.labels.resource.extend(resource.basic.usermetadata.classifications)
+            for fieldmetadata in resource.basic.fieldmetadata:
+                field_id = resource.generate_field_id(fieldmetadata.field)
+                for annotationparagraph in fieldmetadata.paragraphs:
+                    userdefinedparagraphclass[annotationparagraph.key] = annotationparagraph
+
+    for (type_id, field_id), field in fields.items():
+        fieldid = FieldID(field_type=type_id, field=field_id)
+        field_key = resource.generate_field_id(fieldid)
+        fm = await field.get_field_metadata()
+        extracted_text = None
+        vo = None
+        text = None
+
+        if enabled_metadata.vector:
+            # XXX: Given that nobody requested any particular vectorset, we'll
+            # return any
+            vectorset_id = None
+            async with datamanagers.with_ro_transaction() as txn:
+                async for vectorset_id, vs in datamanagers.vectorsets.iter(
+                    txn=txn, kbid=resource.kb.kbid
+                ):
+                    break
+            assert vectorset_id is not None, "All KBs must have at least a vectorset"
+            vo = await field.get_vectors(vectorset_id, vs.storage_key_kind)
+
+        extracted_text = await field.get_extracted_text()
+
+        if fm is None:
+            continue
+
+        field_metadatas: list[tuple[Optional[str], FieldMetadata]] = [(None, fm.metadata)]
+        for subfield_metadata, splitted_metadata in fm.split_metadata.items():
+            field_metadatas.append((subfield_metadata, splitted_metadata))
+
+        for subfield, field_metadata in field_metadatas:
+            if enabled_metadata.labels:
+                metadata.labels.ClearField("field")
+                metadata.labels.field.extend(field_metadata.classifications)
+
+            entities: dict[str, str] = {}
+            if enabled_metadata.entities:
+                _update_entities_dict(entities, field_metadata)
+
+            precomputed_vectors = {}
+            if vo is not None:
+                if subfield is not None:
+                    vectors = vo.split_vectors[subfield]
+                    base_vector_key = f"{resource.uuid}/{field_key}/{subfield}"
+                else:
+                    vectors = vo.vectors
+                    base_vector_key = f"{resource.uuid}/{field_key}"
+                for index, vector in enumerate(vectors.vectors):
+                    vector_key = f"{base_vector_key}/{index}/{vector.start}-{vector.end}"
+                    precomputed_vectors[vector_key] = vector.vector
+
+            if extracted_text is not None:
+                if subfield is not None:
+                    text = extracted_text.split_text[subfield]
+                else:
+                    text = extracted_text.text
+
+            for paragraph in field_metadata.paragraphs:
+                if subfield is not None:
+                    paragraph_key = (
+                        f"{resource.uuid}/{field_key}/{subfield}/{paragraph.start}-{paragraph.end}"
+                    )
+                else:
+                    paragraph_key = f"{resource.uuid}/{field_key}/{paragraph.start}-{paragraph.end}"
+
+                if enabled_metadata.labels:
+                    metadata.labels.ClearField("field")
+                    metadata.labels.paragraph.extend(paragraph.classifications)
+                    if paragraph_key in userdefinedparagraphclass:
+                        metadata.labels.paragraph.extend(
+                            userdefinedparagraphclass[paragraph_key].classifications
+                        )
+
+                for index, sentence in enumerate(paragraph.sentences):
+                    if subfield is not None:
+                        sentence_key = f"{resource.uuid}/{field_key}/{subfield}/{index}/{sentence.start}-{sentence.end}"
+                    else:
+                        sentence_key = (
+                            f"{resource.uuid}/{field_key}/{index}/{sentence.start}-{sentence.end}"
+                        )
+
+                    if vo is not None:
+                        metadata.ClearField("vector")
+                        vector_tmp = precomputed_vectors.get(sentence_key)
+                        if vector_tmp:
+                            metadata.vector.extend(vector_tmp)
+
+                    if extracted_text is not None and text is not None:
+                        metadata.text = text[sentence.start : sentence.end]
+
+                    metadata.ClearField("entities")
+                    metadata.ClearField("entity_positions")
+                    if enabled_metadata.entities and text is not None:
+                        local_text = text[sentence.start : sentence.end]
+                        add_entities_to_metadata(entities, local_text, metadata)
+
+                    pb_sentence = TrainSentence()
+                    pb_sentence.uuid = resource.uuid
+                    pb_sentence.field.CopyFrom(fieldid)
+                    pb_sentence.paragraph = paragraph_key
+                    pb_sentence.sentence = sentence_key
+                    pb_sentence.metadata.CopyFrom(metadata)
+                    yield pb_sentence
+
+
+async def iterate_paragraphs(
+    resource: Resource, enabled_metadata: EnabledMetadata
+) -> AsyncIterator[TrainParagraph]:
+    fields = await resource.get_fields(force=True)
+    metadata = TrainMetadata()
+    userdefinedparagraphclass: dict[str, ParagraphAnnotation] = {}
+    if enabled_metadata.labels:
+        if resource.basic is None:
+            resource.basic = await resource.get_basic()
+        if resource.basic is not None:
+            metadata.labels.resource.extend(resource.basic.usermetadata.classifications)
+            for fieldmetadata in resource.basic.fieldmetadata:
+                field_id = resource.generate_field_id(fieldmetadata.field)
+                for annotationparagraph in fieldmetadata.paragraphs:
+                    userdefinedparagraphclass[annotationparagraph.key] = annotationparagraph
+
+    for (type_id, field_id), field in fields.items():
+        fieldid = FieldID(field_type=type_id, field=field_id)
+        field_key = resource.generate_field_id(fieldid)
+        fm = await field.get_field_metadata()
+        extracted_text = None
+        text = None
+
+        extracted_text = await field.get_extracted_text()
+
+        if fm is None:
+            continue
+
+        field_metadatas: list[tuple[Optional[str], FieldMetadata]] = [(None, fm.metadata)]
+        for subfield_metadata, splitted_metadata in fm.split_metadata.items():
+            field_metadatas.append((subfield_metadata, splitted_metadata))
+
+        for subfield, field_metadata in field_metadatas:
+            if enabled_metadata.labels:
+                metadata.labels.ClearField("field")
+                metadata.labels.field.extend(field_metadata.classifications)
+
+            entities: dict[str, str] = {}
+            if enabled_metadata.entities:
+                _update_entities_dict(entities, field_metadata)
+
+            if extracted_text is not None:
+                if subfield is not None:
+                    text = extracted_text.split_text[subfield]
+                else:
+                    text = extracted_text.text
+
+            for paragraph in field_metadata.paragraphs:
+                if subfield is not None:
+                    paragraph_key = (
+                        f"{resource.uuid}/{field_key}/{subfield}/{paragraph.start}-{paragraph.end}"
+                    )
+                else:
+                    paragraph_key = f"{resource.uuid}/{field_key}/{paragraph.start}-{paragraph.end}"
+
+                if enabled_metadata.labels:
+                    metadata.labels.ClearField("paragraph")
+                    metadata.labels.paragraph.extend(paragraph.classifications)
+
+                    if extracted_text is not None and text is not None:
+                        metadata.text = text[paragraph.start : paragraph.end]
+
+                    metadata.ClearField("entities")
+                    metadata.ClearField("entity_positions")
+                    if enabled_metadata.entities and text is not None:
+                        local_text = text[paragraph.start : paragraph.end]
+                        add_entities_to_metadata(entities, local_text, metadata)
+
+                    if paragraph_key in userdefinedparagraphclass:
+                        metadata.labels.paragraph.extend(
+                            userdefinedparagraphclass[paragraph_key].classifications
+                        )
+
+                    pb_paragraph = TrainParagraph()
+                    pb_paragraph.uuid = resource.uuid
+                    pb_paragraph.field.CopyFrom(fieldid)
+                    pb_paragraph.paragraph = paragraph_key
+                    pb_paragraph.metadata.CopyFrom(metadata)
+
+                    yield pb_paragraph
+
+
+async def iterate_fields(
+    resource: Resource, enabled_metadata: EnabledMetadata
+) -> AsyncIterator[TrainField]:
+    fields = await resource.get_fields(force=True)
+    metadata = TrainMetadata()
+    if enabled_metadata.labels:
+        if resource.basic is None:
+            resource.basic = await resource.get_basic()
+        if resource.basic is not None:
+            metadata.labels.resource.extend(resource.basic.usermetadata.classifications)
+
+    for (type_id, field_id), field in fields.items():
+        fieldid = FieldID(field_type=type_id, field=field_id)
+        fm = await field.get_field_metadata()
+        extracted_text = None
+
+        if enabled_metadata.text:
+            extracted_text = await field.get_extracted_text()
+
+        if fm is None:
+            continue
+
+        field_metadatas: list[tuple[Optional[str], FieldMetadata]] = [(None, fm.metadata)]
+        for subfield_metadata, splitted_metadata in fm.split_metadata.items():
+            field_metadatas.append((subfield_metadata, splitted_metadata))
+
+        for subfield, splitted_metadata in field_metadatas:
+            if enabled_metadata.labels:
+                metadata.labels.ClearField("field")
+                metadata.labels.field.extend(splitted_metadata.classifications)
+
+            if extracted_text is not None:
+                if subfield is not None:
+                    metadata.text = extracted_text.split_text[subfield]
+                else:
+                    metadata.text = extracted_text.text
+
+            if enabled_metadata.entities:
+                metadata.ClearField("entities")
+                _update_entities_dict(metadata.entities, splitted_metadata)
+
+            pb_field = TrainField()
+            pb_field.uuid = resource.uuid
+            pb_field.field.CopyFrom(fieldid)
+            pb_field.metadata.CopyFrom(metadata)
+            yield pb_field
+
+
+async def generate_train_resource(
+    resource: Resource, enabled_metadata: EnabledMetadata
+) -> TrainResource:
+    fields = await resource.get_fields(force=True)
+    metadata = TrainMetadata()
+    if enabled_metadata.labels:
+        if resource.basic is None:
+            resource.basic = await resource.get_basic()
+        if resource.basic is not None:
+            metadata.labels.resource.extend(resource.basic.usermetadata.classifications)
+
+    metadata.labels.ClearField("field")
+    metadata.ClearField("entities")
+
+    for (_, _), field in fields.items():
+        extracted_text = None
+        fm = await field.get_field_metadata()
+
+        if enabled_metadata.text:
+            extracted_text = await field.get_extracted_text()
+
+        if extracted_text is not None:
+            metadata.text += extracted_text.text
+            for text in extracted_text.split_text.values():
+                metadata.text += f" {text}"
+
+        if fm is None:
+            continue
+
+        field_metadatas: list[tuple[Optional[str], FieldMetadata]] = [(None, fm.metadata)]
+        for subfield_metadata, splitted_metadata in fm.split_metadata.items():
+            field_metadatas.append((subfield_metadata, splitted_metadata))
+
+        for _, splitted_metadata in field_metadatas:
+            if enabled_metadata.labels:
+                metadata.labels.field.extend(splitted_metadata.classifications)
+
+            if enabled_metadata.entities:
+                _update_entities_dict(metadata.entities, splitted_metadata)
+
+    pb_resource = TrainResource()
+    pb_resource.uuid = resource.uuid
+    if resource.basic is not None:
+        pb_resource.title = resource.basic.title
+        pb_resource.icon = resource.basic.icon
+        pb_resource.slug = resource.basic.slug
+        pb_resource.modified.CopyFrom(resource.basic.modified)
+        pb_resource.created.CopyFrom(resource.basic.created)
+    pb_resource.metadata.CopyFrom(metadata)
+    return pb_resource
+
+
+def add_entities_to_metadata(entities: dict[str, str], local_text: str, metadata: TrainMetadata) -> None:
+    for entity_key, entity_value in entities.items():
+        if entity_key not in local_text:
+            # Add the entity only if found in text
+            continue
+        metadata.entities[entity_key] = entity_value
+
+        # Add positions for the entity relative to the local text
+        poskey = f"{entity_value}/{entity_key}"
+        metadata.entity_positions[poskey].entity = entity_key
+        last_occurrence_end = 0
+        for _ in range(local_text.count(entity_key)):
+            start = local_text.index(entity_key, last_occurrence_end)
+            end = start + len(entity_key)
+            metadata.entity_positions[poskey].positions.append(TrainPosition(start=start, end=end))
+            last_occurrence_end = end
+
+
+def _update_entities_dict(target_entites_dict: MutableMapping[str, str], field_metadata: FieldMetadata):
+    """
+    Update the entities dict with the entities from the field metadata.
+    Method created to ease the transition from legacy ner field to new entities field.
+    """
+    # Data Augmentation + Processor entities
+    # This will overwrite entities detected from more than one data augmentation task
+    # TODO: Change TrainMetadata proto to accept multiple entities with the same text
+    entity_map = {
+        entity.text: entity.label
+        for data_augmentation_task_id, entities_wrapper in field_metadata.entities.items()
+        for entity in entities_wrapper.entities
+    }
+    target_entites_dict.update(entity_map)
+
+    # Legacy processor entities
+    # TODO: Remove once processor doesn't use this anymore and remove the positions and ner fields from the message
+    target_entites_dict.update(field_metadata.ner)

nucliadb/writer/api/constants.py

@@ -17,21 +17,25 @@
 # 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 TYPE_CHECKING
-
 from fastapi.params import Header
 
-if TYPE_CHECKING:  # pragma: no cover
-    SKIP_STORE_DEFAULT = False
-    X_NUCLIADB_USER = ""
-    X_FILE_PASSWORD = None
-else:
-    SKIP_STORE_DEFAULT = Header(
-        False,
-        description="If set to true, file fields will not be saved in the blob storage. They will only be sent to process.",  # noqa
-    )
-    X_NUCLIADB_USER = Header("")
-    X_FILE_PASSWORD = Header(
-        None,
-        description="If a file is password protected, the password must be provided here for the file to be processed",  # noqa
-    )
+X_SKIP_STORE = Header(
+    description="If set to true, file fields will not be saved in the blob storage. They will only be sent to process.",
+)
+X_NUCLIADB_USER = Header()
+X_FILE_PASSWORD = Header(
+    description="If a file is password protected, the password must be provided here for the file to be processed",
+)
+X_EXTRACT_STRATEGY = Header(
+    description="Extract strategy to use when uploading a file. If not provided, the default strategy will be used.",
+)
+X_FILENAME = Header(min_length=1, description="Name of the file being uploaded.")
+X_MD5 = Header(
+    min_length=32,
+    max_length=32,
+    description="MD5 hash of the file being uploaded. This is used to check if the file has been uploaded before.",
+)
+X_PASSWORD = Header(
+    min_length=1, description="If the file is password protected, the password must be provided here."
+)
+X_LANGUAGE = Header()

nucliadb/writer/api/v1/__init__.py

@@ -24,4 +24,5 @@ from . import learning_config  # noqa
 from . import resource  # noqa
 from . import services  # noqa
 from . import upload  # noqa
+from . import vectorsets  # noqa
 from .router import api  # noqa

nucliadb/writer/api/v1/export_import.py

@@ -112,7 +112,7 @@ async def kb_create_and_import_endpoint(request: Request):
     now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     import_kb_config = KnowledgeBoxConfig(
         title=f"Imported KB - {now}",
-        learning_configuration=learning_config.dict(),
+        learning_configuration=learning_config.model_dump(),
     )
     kbid, slug = await create_kb(import_kb_config)
 

nucliadb/writer/api/v1/field.py

@@ -18,7 +18,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 from inspect import iscoroutinefunction
-from typing import TYPE_CHECKING, Callable, Optional, Type, Union
+from typing import TYPE_CHECKING, Annotated, Callable, Optional, Type, Union
 
 from fastapi import HTTPException, Response
 from fastapi_versioning import version
@@ -30,9 +30,9 @@ from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
 from nucliadb.ingest.processing import PushPayload, Source
 from nucliadb.writer import SERVICE_NAME
 from nucliadb.writer.api.constants import (
-    SKIP_STORE_DEFAULT,
     X_FILE_PASSWORD,
     X_NUCLIADB_USER,
+    X_SKIP_STORE,
 )
 from nucliadb.writer.api.v1 import transaction
 from nucliadb.writer.api.v1.resource import (
@@ -55,7 +55,7 @@ from nucliadb_models.utils import FieldIdString
 from nucliadb_models.writer import ResourceFieldAdded, ResourceUpdated
 from nucliadb_protos import resources_pb2
 from nucliadb_protos.resources_pb2 import FieldID, Metadata
-from nucliadb_protos.writer_pb2 import BrokerMessage
+from nucliadb_protos.writer_pb2 import BrokerMessage, FieldIDStatus, FieldStatus
 from nucliadb_utils.authentication import requires
 from nucliadb_utils.exceptions import LimitsExceededError, SendToProcessError
 from nucliadb_utils.utilities import (
@@ -380,7 +380,7 @@ async def add_resource_field_file_rslug_prefix(
     rslug: str,
     field_id: FieldIdString,
     field_payload: models.FileField,
-    x_skip_store: bool = SKIP_STORE_DEFAULT,
+    x_skip_store: Annotated[bool, X_SKIP_STORE] = False,
 ) -> ResourceFieldAdded:
     return await add_field_to_resource_by_slug(
         request, kbid, rslug, field_id, field_payload, skip_store=x_skip_store
@@ -402,7 +402,7 @@ async def add_resource_field_file_rid_prefix(
     rid: str,
     field_id: FieldIdString,
     field_payload: models.FileField,
-    x_skip_store: bool = SKIP_STORE_DEFAULT,
+    x_skip_store: Annotated[bool, X_SKIP_STORE] = False,
 ) -> ResourceFieldAdded:
     return await add_field_to_resource(
         request, kbid, rid, field_id, field_payload, skip_store=x_skip_store
@@ -503,8 +503,8 @@ async def reprocess_file_field(
     kbid: str,
     rid: str,
     field_id: FieldIdString,
-    x_nucliadb_user: str = X_NUCLIADB_USER,
-    x_file_password: Optional[str] = X_FILE_PASSWORD,
+    x_nucliadb_user: Annotated[str, X_NUCLIADB_USER] = "",
+    x_file_password: Annotated[Optional[str], X_FILE_PASSWORD] = None,
 ) -> ResourceUpdated:
     await maybe_back_pressure(request, kbid, resource_uuid=rid)
 
@@ -553,6 +553,12 @@ async def reprocess_file_field(
     writer.source = BrokerMessage.MessageSource.WRITER
     writer.basic.metadata.useful = True
     writer.basic.metadata.status = Metadata.Status.PENDING
+    writer.field_statuses.append(
+        FieldIDStatus(
+            id=FieldID(field_type=resources_pb2.FieldType.FILE, field=field_id),
+            status=FieldStatus.Status.PENDING,
+        )
+    )
     await transaction.commit(writer, partition, wait=False)
     # Send current resource to reprocess.
     try: