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

nucliadb/ingest/fields/base.py

@@ -21,57 +21,54 @@ from __future__ import annotations
 
 import enum
 from datetime import datetime
-from typing import Any, Optional, Type
+from typing import Any, Generic, Optional, Type, TypeVar
 
+from google.protobuf.message import DecodeError, Message
+
+from nucliadb.common import datamanagers
+from nucliadb.ingest.fields.exceptions import InvalidFieldClass, InvalidPBClass
 from nucliadb_protos.resources_pb2 import (
     CloudFile,
     ExtractedTextWrapper,
     ExtractedVectorsWrapper,
+    FieldAuthor,
     FieldComputedMetadata,
     FieldComputedMetadataWrapper,
+    FieldQuestionAnswers,
     FieldQuestionAnswerWrapper,
     LargeComputedMetadata,
     LargeComputedMetadataWrapper,
     QuestionAnswers,
-    UserVectorsWrapper,
-)
-from nucliadb_protos.utils_pb2 import (
-    ExtractedText,
-    UserVectorSet,
-    UserVectorsList,
-    VectorObject,
 )
+from nucliadb_protos.utils_pb2 import ExtractedText, VectorObject
 from nucliadb_protos.writer_pb2 import Error
-
-from nucliadb.ingest.fields.exceptions import InvalidFieldClass, InvalidPBClass
 from nucliadb_utils.storages.storage import Storage, StorageField
 
-KB_RESOURCE_FIELD = "/kbs/{kbid}/r/{uuid}/f/{type}/{field}"
-KB_RESOURCE_ERROR = "/kbs/{kbid}/r/{uuid}/f/{type}/{field}/error"
-
-SUBFIELDFIELDS = ["l", "c"]
+SUBFIELDFIELDS = ("c",)
 
 
 class FieldTypes(str, enum.Enum):
     FIELD_TEXT = "extracted_text"
     FIELD_VECTORS = "extracted_vectors"
-    USER_FIELD_VECTORS = "user_vectors"
+    FIELD_VECTORSET = "{vectorset}/extracted_vectors"
     FIELD_METADATA = "metadata"
     FIELD_LARGE_METADATA = "large_metadata"
     THUMBNAIL = "thumbnail"
     QUESTION_ANSWERS = "question_answers"
 
 
-class Field:
-    pbklass: Optional[Type] = None
+PbType = TypeVar("PbType", bound=Message)
+
+
+class Field(Generic[PbType]):
+    pbklass: Type[PbType]
     type: str = "x"
     value: Optional[Any]
     extracted_text: Optional[ExtractedText]
-    extracted_vectors: Optional[VectorObject]
+    extracted_vectors: dict[Optional[str], VectorObject]
     computed_metadata: Optional[FieldComputedMetadata]
     large_computed_metadata: Optional[LargeComputedMetadata]
-    extracted_user_vectors: Optional[UserVectorSet]
-    question_answers: Optional[QuestionAnswers]
+    question_answers: Optional[FieldQuestionAnswers]
 
     def __init__(
         self,
@@ -85,10 +82,9 @@ class Field:
 
         self.value = None
         self.extracted_text: Optional[ExtractedText] = None
-        self.extracted_vectors = None
+        self.extracted_vectors = {}
         self.computed_metadata = None
         self.large_computed_metadata = None
-        self.extracted_user_vectors = None
         self.question_answers = None
 
         self.id: str = id
@@ -121,44 +117,51 @@ class Field:
         return f"{self.uuid}/{self.type}/{self.id}"
 
     def get_storage_field(self, field_type: FieldTypes) -> StorageField:
-        return self.storage.file_extracted(
-            self.kbid, self.uuid, self.type, self.id, field_type.value
-        )
+        return self.storage.file_extracted(self.kbid, self.uuid, self.type, self.id, field_type.value)
+
+    def _get_extracted_vectors_storage_field(self, vectorset: Optional[str] = None) -> StorageField:
+        if vectorset:
+            key = FieldTypes.FIELD_VECTORSET.value.format(vectorset=vectorset)
+        else:
+            key = FieldTypes.FIELD_VECTORS.value
+        return self.storage.file_extracted(self.kbid, self.uuid, self.type, self.id, key)
 
-    async def db_get_value(self):
+    async def db_get_value(self) -> Optional[PbType]:
         if self.value is None:
-            payload = await self.resource.txn.get(
-                KB_RESOURCE_FIELD.format(
-                    kbid=self.kbid, uuid=self.uuid, type=self.type, field=self.id
-                )
+            payload = await datamanagers.fields.get_raw(
+                self.resource.txn,
+                kbid=self.kbid,
+                rid=self.uuid,
+                field_type=self.type,
+                field_id=self.id,
             )
             if payload is None:
-                return
+                return None
 
             self.value = self.pbklass()
             self.value.ParseFromString(payload)
         return self.value
 
     async def db_set_value(self, payload: Any):
-        await self.resource.txn.set(
-            KB_RESOURCE_FIELD.format(
-                kbid=self.kbid, uuid=self.uuid, type=self.type, field=self.id
-            ),
-            payload.SerializeToString(),
+        await datamanagers.fields.set(
+            self.resource.txn,
+            kbid=self.kbid,
+            rid=self.uuid,
+            field_type=self.type,
+            field_id=self.id,
+            value=payload,
         )
         self.value = payload
         self.resource.modified = True
 
     async def delete(self):
-        field_base_key = KB_RESOURCE_FIELD.format(
-            kbid=self.kbid, uuid=self.uuid, type=self.type, field=self.id
+        await datamanagers.fields.delete(
+            self.resource.txn,
+            kbid=self.kbid,
+            rid=self.uuid,
+            field_type=self.type,
+            field_id=self.id,
         )
-        # Make sure we explicitly delete the field and any nested key
-        keys_to_delete = []
-        async for key in self.resource.txn.keys(field_base_key):
-            keys_to_delete.append(key)
-        for key in keys_to_delete:
-            await self.resource.txn.delete(key)
         await self.delete_extracted_text()
         await self.delete_vectors()
         await self.delete_metadata()
@@ -178,9 +181,9 @@ class Field:
         except KeyError:
             pass
 
-    async def delete_vectors(self) -> None:
+    async def delete_vectors(self, vectorset: Optional[str] = None) -> None:
         # Try delete vectors
-        sf = self.get_storage_field(FieldTypes.FIELD_VECTORS)
+        sf = self._get_extracted_vectors_storage_field(vectorset)
         try:
             await self.storage.delete_upload(sf.key, sf.bucket)
         except KeyError:
@@ -194,53 +197,79 @@ class Field:
             pass
 
     async def get_error(self) -> Optional[Error]:
-        payload = await self.resource.txn.get(
-            KB_RESOURCE_ERROR.format(
-                kbid=self.kbid, uuid=self.uuid, type=self.type, field=self.id
-            )
+        return await datamanagers.fields.get_error(
+            self.resource.txn,
+            kbid=self.kbid,
+            rid=self.uuid,
+            field_type=self.type,
+            field_id=self.id,
         )
-        if payload is None:
-            return None
-        pberror = Error()
-        pberror.ParseFromString(payload)
-        return pberror
 
     async def set_error(self, error: Error) -> None:
-        await self.resource.txn.set(
-            KB_RESOURCE_ERROR.format(
-                kbid=self.kbid, uuid=self.uuid, type=self.type, field=self.id
-            ),
-            error.SerializeToString(),
+        await datamanagers.fields.set_error(
+            self.resource.txn,
+            kbid=self.kbid,
+            rid=self.uuid,
+            field_type=self.type,
+            field_id=self.id,
+            error=error,
         )
 
-    async def get_question_answers(self) -> Optional[QuestionAnswers]:
-        if self.question_answers is None:
+    async def get_question_answers(self, force=False) -> Optional[FieldQuestionAnswers]:
+        if self.question_answers is None or force:
             sf = self.get_storage_field(FieldTypes.QUESTION_ANSWERS)
-            payload = await self.storage.download_pb(sf, QuestionAnswers)
+            try:
+                payload = await self.storage.download_pb(sf, FieldQuestionAnswers)
+            except DecodeError:
+                deprecated_payload = await self.storage.download_pb(sf, QuestionAnswers)
+                if deprecated_payload is not None:
+                    payload = FieldQuestionAnswers()
+                    payload.question_answers.CopyFrom(deprecated_payload)
             if payload is not None:
                 self.question_answers = payload
         return self.question_answers
 
     async def set_question_answers(self, payload: FieldQuestionAnswerWrapper) -> None:
+        if self.type in SUBFIELDFIELDS:
+            try:
+                actual_payload: Optional[FieldQuestionAnswers] = await self.get_question_answers(
+                    force=True
+                )
+            except KeyError:
+                actual_payload = None
+        else:
+            actual_payload = None
         sf = self.get_storage_field(FieldTypes.QUESTION_ANSWERS)
 
-        if payload.HasField("file"):
-            raw_payload = await self.storage.downloadbytescf(payload.file)
-            pb = QuestionAnswers()
-            pb.ParseFromString(raw_payload.read())
-            raw_payload.flush()
-            self.question_answers = pb
+        if actual_payload is None:
+            # Its first question answer
+            if payload.HasField("file"):
+                await self.storage.normalize_binary(payload.file, sf)
+            else:
+                await self.storage.upload_pb(sf, payload.question_answers)
+                self.question_answers = payload.question_answers
         else:
-            self.question_answers = payload.question_answers
-
-        await self.storage.upload_pb(sf, self.question_answers)
+            if payload.HasField("file"):
+                raw_payload = await self.storage.downloadbytescf(payload.file)
+                pb = FieldQuestionAnswers()
+                pb.ParseFromString(raw_payload.read())
+                raw_payload.flush()
+                payload.question_answers.CopyFrom(pb)
+            # We know its payload.question_answers
+            for key, value in payload.question_answers.split_question_answers.items():
+                actual_payload.split_question_answers[key] = value
+            for key in payload.question_answers.deleted_splits:
+                if key in actual_payload.split_question_answers:
+                    del actual_payload.split_question_answers[key]
+            if payload.question_answers.HasField("question_answers") != "":
+                actual_payload.question_answers.CopyFrom(payload.question_answers.question_answers)
+            await self.storage.upload_pb(sf, actual_payload)
+            self.question_answers = actual_payload
 
     async def set_extracted_text(self, payload: ExtractedTextWrapper) -> None:
         if self.type in SUBFIELDFIELDS:
             try:
-                actual_payload: Optional[ExtractedText] = await self.get_extracted_text(
-                    force=True
-                )
+                actual_payload: Optional[ExtractedText] = await self.get_extracted_text(force=True)
             except KeyError:
                 actual_payload = None
         else:
@@ -280,30 +309,21 @@ class Field:
                 self.extracted_text = payload
         return self.extracted_text
 
-    async def get_extracted_text_cf(self) -> Optional[CloudFile]:
-        sf = self.get_storage_field(FieldTypes.FIELD_TEXT)
-        if await sf.exists() is not None:
-            return sf.build_cf()
-        else:
-            return None
-
-    async def set_vectors(
-        self, payload: ExtractedVectorsWrapper
-    ) -> tuple[Optional[VectorObject], bool, list[str]]:
+    async def set_vectors(self, payload: ExtractedVectorsWrapper) -> Optional[VectorObject]:
+        vectorset = payload.vectorset_id or None
         if self.type in SUBFIELDFIELDS:
             try:
                 actual_payload: Optional[VectorObject] = await self.get_vectors(
-                    force=True
+                    vectorset=vectorset,
+                    force=True,
                 )
             except KeyError:
                 actual_payload = None
         else:
             actual_payload = None
 
-        sf = self.get_storage_field(FieldTypes.FIELD_VECTORS)
+        sf = self._get_extracted_vectors_storage_field(vectorset)
         vo: Optional[VectorObject] = None
-        replace_field: bool = True
-        replace_splits = []
         if actual_payload is None:
             # Its first extracted text
             if payload.HasField("file"):
@@ -312,7 +332,7 @@ class Field:
             else:
                 await self.storage.upload_pb(sf, payload.vectors)
                 vo = payload.vectors
-                self.extracted_vectors = payload.vectors
+                self.extracted_vectors[vectorset] = payload.vectors
         else:
             if payload.HasField("file"):
                 raw_payload = await self.storage.downloadbytescf(payload.file)
@@ -320,88 +340,39 @@ class Field:
                 pb.ParseFromString(raw_payload.read())
                 raw_payload.flush()
                 payload.vectors.CopyFrom(pb)
-            vo = payload.vectors
+            vo = actual_payload
             # We know its payload.body
             for key, value in payload.vectors.split_vectors.items():
                 actual_payload.split_vectors[key].CopyFrom(value)
             for key in payload.vectors.deleted_splits:
                 if key in actual_payload.split_vectors:
-                    replace_splits.append(key)
                     del actual_payload.split_vectors[key]
             if len(payload.vectors.vectors.vectors) > 0:
-                replace_field = True
                 actual_payload.vectors.CopyFrom(payload.vectors.vectors)
             await self.storage.upload_pb(sf, actual_payload)
-            self.extracted_vectors = actual_payload
-        return vo, replace_field, replace_splits
-
-    async def get_vectors(self, force=False) -> Optional[VectorObject]:
-        if self.extracted_vectors is None or force:
-            sf = self.get_storage_field(FieldTypes.FIELD_VECTORS)
+            self.extracted_vectors[vectorset] = actual_payload
+        return vo
+
+    async def get_vectors(
+        self, vectorset: Optional[str] = None, force: bool = False
+    ) -> Optional[VectorObject]:
+        # compat with vectorsets coming from protobuffers where no value is
+        # empty string instead of None. This shouldn't be handled here but we
+        # have to make sure it gets the correct vectorset
+        vectorset = vectorset or None
+        if self.extracted_vectors.get(vectorset, None) is None or force:
+            sf = self._get_extracted_vectors_storage_field(vectorset)
             payload = await self.storage.download_pb(sf, VectorObject)
             if payload is not None:
-                self.extracted_vectors = payload
-        return self.extracted_vectors
-
-    async def set_user_vectors(
-        self, user_vectors: UserVectorsWrapper
-    ) -> tuple[UserVectorSet, dict[str, UserVectorsList]]:
-        try:
-            actual_payload: Optional[UserVectorSet] = await self.get_user_vectors(
-                force=True
-            )
-        except KeyError:
-            actual_payload = None
-
-        sf = self.get_storage_field(FieldTypes.USER_FIELD_VECTORS)
-
-        vectors_to_delete: dict[str, UserVectorsList] = {}
-        if actual_payload is not None:
-            for vectorset, user_vector in user_vectors.vectors.vectors.items():
-                for key, vector in user_vector.vectors.items():
-                    if key in actual_payload.vectors[vectorset].vectors.keys():
-                        if vectorset not in vectors_to_delete:
-                            vectors_to_delete[vectorset] = UserVectorsList()
-                        vectors_to_delete[vectorset].vectors.append(key)
-                    actual_payload.vectors[vectorset].vectors[key].CopyFrom(vector)
-            for vectorset, delete_vectors in user_vectors.vectors_to_delete.items():
-                for vector_to_delete in delete_vectors.vectors:
-                    if (
-                        actual_payload.vectors.get(vectorset).vectors.get(
-                            vector_to_delete
-                        )
-                        is not None
-                    ):
-                        del actual_payload.vectors[vectorset].vectors[vector_to_delete]
-        else:
-            actual_payload = user_vectors.vectors
-        await self.storage.upload_pb(sf, actual_payload)
-        self.extracted_user_vectors = actual_payload
-        return actual_payload, vectors_to_delete
-
-    async def get_user_vectors(self, force=False) -> Optional[UserVectorSet]:
-        if self.extracted_user_vectors is None or force:
-            sf = self.get_storage_field(FieldTypes.USER_FIELD_VECTORS)
-            payload = await self.storage.download_pb(sf, UserVectorSet)
-            if payload is not None:
-                self.extracted_user_vectors = payload
-        return self.extracted_user_vectors
-
-    async def get_vectors_cf(self) -> Optional[CloudFile]:
-        sf = self.get_storage_field(FieldTypes.FIELD_VECTORS)
-        if await sf.exists() is not None:
-            return sf.build_cf()
-        else:
-            return None
+                self.extracted_vectors[vectorset] = payload
+        return self.extracted_vectors.get(vectorset, None)
 
-    async def set_field_metadata(
-        self, payload: FieldComputedMetadataWrapper
-    ) -> tuple[FieldComputedMetadata, list[str], dict[str, list[str]]]:
+    async def set_field_metadata(self, payload: FieldComputedMetadataWrapper) -> FieldComputedMetadata:
         if self.type in SUBFIELDFIELDS:
             try:
-                actual_payload: Optional[
-                    FieldComputedMetadata
-                ] = await self.get_field_metadata(force=True)
+                actual_payload: Optional[FieldComputedMetadata] = await self.get_field_metadata(
+                    force=True
+                )
             except KeyError:
                 actual_payload = None
         else:
@@ -426,8 +397,6 @@ class Field:
                 metadata.thumbnail.CopyFrom(cf_split)
             metadata.last_index.FromDatetime(datetime.now())
 
-        replace_field = []
-        replace_splits = {}
         if actual_payload is None:
             # Its first metadata
             await self.storage.upload_pb(sf, payload.metadata)
@@ -438,22 +407,15 @@ class Field:
                 actual_payload.split_metadata[key].CopyFrom(value)
             for key in payload.metadata.deleted_splits:
                 if key in actual_payload.split_metadata:
-                    replace_splits[key] = [
-                        f"{x.start}-{x.end}"
-                        for x in actual_payload.split_metadata[key].paragraphs
-                    ]
                     del actual_payload.split_metadata[key]
             if payload.metadata.metadata:
                 actual_payload.metadata.CopyFrom(payload.metadata.metadata)
-                replace_field = [f"{x.start}-{x.end}" for x in metadata.paragraphs]
             await self.storage.upload_pb(sf, actual_payload)
             self.computed_metadata = actual_payload
 
-        return self.computed_metadata, replace_field, replace_splits
+        return self.computed_metadata
 
-    async def get_field_metadata(
-        self, force: bool = False
-    ) -> Optional[FieldComputedMetadata]:
+    async def get_field_metadata(self, force: bool = False) -> Optional[FieldComputedMetadata]:
         if self.computed_metadata is None or force:
             sf = self.get_storage_field(FieldTypes.FIELD_METADATA)
             payload = await self.storage.download_pb(sf, FieldComputedMetadata)
@@ -461,19 +423,12 @@ class Field:
                 self.computed_metadata = payload
         return self.computed_metadata
 
-    async def get_field_metadata_cf(self) -> Optional[CloudFile]:
-        sf = self.get_storage_field(FieldTypes.FIELD_METADATA)
-        if await sf.exists() is not None:
-            return sf.build_cf()
-        else:
-            return None
-
     async def set_large_field_metadata(self, payload: LargeComputedMetadataWrapper):
         if self.type in SUBFIELDFIELDS:
             try:
-                actual_payload: Optional[
-                    LargeComputedMetadata
-                ] = await self.get_large_field_metadata(force=True)
+                actual_payload: Optional[LargeComputedMetadata] = await self.get_large_field_metadata(
+                    force=True
+                )
             except KeyError:
                 actual_payload = None
         else:
@@ -508,9 +463,7 @@ class Field:
 
         return self.large_computed_metadata
 
-    async def get_large_field_metadata(
-        self, force: bool = False
-    ) -> Optional[LargeComputedMetadata]:
+    async def get_large_field_metadata(self, force: bool = False) -> Optional[LargeComputedMetadata]:
         if self.large_computed_metadata is None or force:
             sf = self.get_storage_field(FieldTypes.FIELD_LARGE_METADATA)
             payload = await self.storage.download_pb(
@@ -521,12 +474,10 @@ class Field:
                 self.large_computed_metadata = payload
         return self.large_computed_metadata
 
-    async def get_large_field_metadata_cf(self) -> Optional[CloudFile]:
-        sf = self.get_storage_field(FieldTypes.FIELD_LARGE_METADATA)
-        if await sf.exists() is not None:
-            return sf.build_cf()
-        else:
-            return None
+    async def generated_by(self) -> FieldAuthor:
+        author = FieldAuthor()
+        author.user.SetInParent()
+        return author
 
     def serialize(self):
         return self.value.SerializeToString()

nucliadb/ingest/fields/conversation.py

@@ -20,11 +20,9 @@
 import uuid
 from typing import Any, Optional
 
-from nucliadb_protos.resources_pb2 import CloudFile
-from nucliadb_protos.resources_pb2 import Conversation as PBConversation
-from nucliadb_protos.resources_pb2 import FieldConversation
-
 from nucliadb.ingest.fields.base import Field
+from nucliadb_protos.resources_pb2 import CloudFile, FieldConversation
+from nucliadb_protos.resources_pb2 import Conversation as PBConversation
 from nucliadb_utils.storages.storage import StorageField
 
 PAGE_SIZE = 200
@@ -36,7 +34,7 @@ class PageNotFound(Exception):
     pass
 
 
-class Conversation(Field):
+class Conversation(Field[PBConversation]):
     pbklass = PBConversation
     type: str = "c"
     value: dict[int, PBConversation]
@@ -120,6 +118,21 @@ class Conversation(Field):
         except PageNotFound:
             return None
 
+    async def get_full_conversation(self) -> Optional[PBConversation]:
+        """
+        Messages of a conversations may be stored across several pages.
+        This method fetches them all and returns a single complete conversation.
+        """
+        full_conv = PBConversation()
+        n_page = 1
+        while True:
+            page = await self.get_value(page=n_page)
+            if page is None:
+                break
+            full_conv.messages.extend(page.messages)
+            n_page += 1
+        return full_conv
+
     async def get_metadata(self) -> FieldConversation:
         if self.metadata is None:
             payload = await self.resource.txn.get(

nucliadb/ingest/fields/exceptions.py

@@ -28,7 +28,4 @@ class InvalidPBClass(Exception):
     def __init__(self, source: Type, destination: Type):
         self.source = source
         self.destination = destination
-        super().__init__(
-            "Source and destination does not match "
-            f"{self.source} - {self.destination}"
-        )
+        super().__init__("Source and destination does not match " f"{self.source} - {self.destination}")

nucliadb/ingest/fields/file.py

@@ -19,15 +19,14 @@
 #
 from typing import Any, Optional
 
-from nucliadb_protos.resources_pb2 import CloudFile, FieldFile, FileExtractedData
-
 from nucliadb.ingest.fields.base import Field
+from nucliadb_protos.resources_pb2 import CloudFile, FieldFile, FileExtractedData
 from nucliadb_utils.storages.storage import StorageField
 
 FILE_METADATA = "file_metadata"
 
 
-class File(Field):
+class File(Field[FieldFile]):
     pbklass = FieldFile
     value: FieldFile
     type: str = "f"
@@ -52,15 +51,13 @@ class File(Field):
 
         is_external_file = payload.file.source == CloudFile.Source.EXTERNAL
         if not is_external_file:
-            sf: StorageField = self.storage.file_field(
-                self.kbid, self.uuid, self.id, old_cf
-            )
+            sf: StorageField = self.storage.file_field(self.kbid, self.uuid, self.id, old_cf)
             cf: CloudFile = await self.storage.normalize_binary(payload.file, sf)
             payload.file.CopyFrom(cf)
 
         await self.db_set_value(payload)
 
-    async def get_value(self) -> FieldFile:
+    async def get_value(self) -> Optional[FieldFile]:
         return await self.db_get_value()
 
     async def set_file_extracted_data(self, file_extracted_data: FileExtractedData):
@@ -80,17 +77,13 @@ class File(Field):
             cf_file_page_preview: CloudFile = await self.storage.normalize_binary(
                 preview, sf_file_page_preview
             )
-            file_extracted_data.file_pages_previews.pages[page].CopyFrom(
-                cf_file_page_preview
-            )
+            file_extracted_data.file_pages_previews.pages[page].CopyFrom(cf_file_page_preview)
 
         for fileid, origincf in file_extracted_data.file_generated.items():
             sf_generated: StorageField = self.storage.file_extracted(
                 self.kbid, self.uuid, self.type, self.id, f"generated/{fileid}"
             )
-            cf_generated: CloudFile = await self.storage.normalize_binary(
-                origincf, sf_generated
-            )
+            cf_generated: CloudFile = await self.storage.normalize_binary(origincf, sf_generated)
             file_extracted_data.file_generated[fileid].CopyFrom(cf_generated)
 
         if file_extracted_data.HasField("file_thumbnail"):
@@ -113,16 +106,5 @@ class File(Field):
             sf: StorageField = self.storage.file_extracted(
                 self.kbid, self.uuid, self.type, self.id, FILE_METADATA
             )
-            self.file_extracted_data = await self.storage.download_pb(
-                sf, FileExtractedData
-            )
+            self.file_extracted_data = await self.storage.download_pb(sf, FileExtractedData)
         return self.file_extracted_data
-
-    async def get_file_extracted_data_cf(self) -> Optional[CloudFile]:
-        sf: StorageField = self.storage.file_extracted(
-            self.kbid, self.uuid, self.type, self.id, FILE_METADATA
-        )
-        if await sf.exists() is not None:
-            return sf.build_cf()
-        else:
-            return None