nucliadb 6.7.2.post4862__py3-none-any.whl → 6.9.2.post5282__py3-none-any.whl

nucliadb/reader/api/v1/learning_config.py

@@ -19,7 +19,7 @@
 #
 from typing import Dict
 
-from fastapi import Request
+from fastapi import Header, Request
 from fastapi_versioning import version
 from nuclia_models.config.proto import ExtractConfig, SplitConfiguration
 
@@ -60,15 +60,11 @@ async def download_model(
 )
 @requires_one([NucliaDBRoles.READER, NucliaDBRoles.MANAGER])
 @version(1)
-async def get_configuration(
-    request: Request,
-    kbid: str,
-):
+async def get_configuration(request: Request, kbid: str):
     return await learning_config_proxy(
         request,
         "GET",
         f"/config/{kbid}",
-        extra_headers={"X-STF-USER": request.headers.get("X-NUCLIADB-USER", "")},
     )
 
 
@@ -108,7 +104,6 @@ async def get_model(
         request,
         "GET",
         f"/models/{kbid}/model/{model_id}",
-        extra_headers={"X-STF-USER": request.headers.get("X-NUCLIADB-USER", "")},
     )
 
 
@@ -123,10 +118,35 @@ async def get_model(
 @requires_one([NucliaDBRoles.READER, NucliaDBRoles.MANAGER])
 @version(1)
 async def get_schema_for_configuration_updates(
-    request: Request,
-    kbid: str,
+    request: Request, kbid: str, x_nucliadb_account: str = Header(default="", include_in_schema=False)
 ):
-    return await learning_config_proxy(request, "GET", f"/schema/{kbid}")
+    return await learning_config_proxy(
+        request,
+        "GET",
+        f"/schema/{kbid}",
+        headers={"account-id": x_nucliadb_account},
+    )
+
+
+@api.get(
+    path=f"/{KB_PREFIX}/{{kbid}}/generative_providers",
+    status_code=200,
+    summary="Available models for a knowledge box",
+    description="Get all available models for a knowledge box grouped by provider",
+    response_model=None,
+    tags=["Models"],
+)
+@requires_one([NucliaDBRoles.READER, NucliaDBRoles.MANAGER])
+@version(1)
+async def get_models_group_by_providers(
+    request: Request, kbid: str, x_nucliadb_account: str = Header(default="", include_in_schema=False)
+):
+    return await learning_config_proxy(
+        request,
+        "GET",
+        f"/generative_providers/{kbid}",
+        headers={"account-id": x_nucliadb_account},
+    )
 
 
 @api.get(

nucliadb/reader/api/v1/resource.py

@@ -77,7 +77,7 @@ async def list_resources(
 
     # Get counters from maindb
     driver = get_driver()
-    async with driver.transaction(read_only=True) as txn:
+    async with driver.ro_transaction() as txn:
         # Filter parameters for serializer
         show: list[ResourceProperties] = [ResourceProperties.BASIC]
         field_types: list[FieldTypeName] = []
@@ -335,7 +335,7 @@ async def _get_resource_field(
     storage = await get_storage(service_name=SERVICE_NAME)
     driver = get_driver()
     pb_field_id = to_proto.field_type_name(field_type)
-    async with driver.transaction(read_only=True) as txn:
+    async with driver.ro_transaction() as txn:
         kb = ORMKnowledgeBox(txn, storage, kbid)
 
         if rid is None:

nucliadb/reader/api/v1/services.py

@@ -287,7 +287,7 @@ async def processing_status(
     storage = await get_storage(service_name=SERVICE_NAME)
     driver = get_driver()
 
-    async with driver.transaction(read_only=True) as txn:
+    async with driver.ro_transaction() as txn:
         kb = KnowledgeBox(txn, storage, kbid)
 
         max_simultaneous = asyncio.Semaphore(10)

nucliadb/reader/reader/notifications.py

@@ -201,7 +201,7 @@ async def get_resource_title_cached(
 
 
 async def get_resource_title(kv_driver: Driver, kbid: str, resource_uuid: str) -> Optional[str]:
-    async with kv_driver.transaction(read_only=True) as txn:
+    async with kv_driver.ro_transaction() as txn:
         basic = await datamanagers.resources.get_basic(txn, kbid=kbid, rid=resource_uuid)
         if basic is None:
             return None

nucliadb/search/api/v1/__init__.py

@@ -23,6 +23,7 @@ from . import (  # noqa: F401
     feedback,
     find,
     graph,
+    hydrate,
     knowledgebox,
     predict_proxy,
     search,

nucliadb/search/api/v1/catalog.py

@@ -25,6 +25,7 @@ from fastapi import Request, Response
 from fastapi_versioning import version
 from pydantic import ValidationError
 
+from nucliadb.common.catalog import catalog_facets, catalog_search
 from nucliadb.common.datamanagers.exceptions import KnowledgeBoxNotFound
 from nucliadb.common.exceptions import InvalidQueryError
 from nucliadb.models.responses import HTTPClientError
@@ -33,7 +34,6 @@ from nucliadb.search.api.v1.router import KB_PREFIX, api
 from nucliadb.search.api.v1.utils import fastapi_query
 from nucliadb.search.search import cache
 from nucliadb.search.search.merge import fetch_resources
-from nucliadb.search.search.pgcatalog import pgcatalog_facets, pgcatalog_search
 from nucliadb.search.search.query_parser.parsers import parse_catalog
 from nucliadb.search.search.utils import (
     maybe_log_request_payload,
@@ -164,7 +164,7 @@ async def catalog(
             query_parser = await parse_catalog(kbid, item)
 
             catalog_results = CatalogResponse()
-            catalog_results.fulltext = await pgcatalog_search(query_parser)
+            catalog_results.fulltext = await catalog_search(query_parser)
             catalog_results.resources = await fetch_resources(
                 resources=[r.rid for r in catalog_results.fulltext.results],
                 kbid=kbid,
@@ -205,7 +205,7 @@ async def catalog(
 )
 @requires(NucliaDBRoles.READER)
 @version(1)
-async def catalog_facets(
+async def catalog_facets_endpoint(
     request: Request, kbid: str, item: CatalogFacetsRequest
 ) -> CatalogFacetsResponse:
-    return CatalogFacetsResponse(facets=await pgcatalog_facets(kbid, item))
+    return CatalogFacetsResponse(facets=await catalog_facets(kbid, item))

nucliadb/search/api/v1/find.py

@@ -46,7 +46,6 @@ from nucliadb_models.search import (
     KnowledgeboxFindResults,
     NucliaDBClientType,
     RankFusionName,
-    Reranker,
     RerankerName,
     ResourceProperties,
     SearchParamDefaults,
@@ -127,11 +126,10 @@ async def find_knowledgebox(
     extracted: list[ExtractedDataTypeName] = fastapi_query(SearchParamDefaults.extracted),
     with_duplicates: bool = fastapi_query(SearchParamDefaults.with_duplicates),
     with_synonyms: bool = fastapi_query(SearchParamDefaults.with_synonyms),
-    autofilter: bool = fastapi_query(SearchParamDefaults.autofilter),
     security_groups: list[str] = fastapi_query(SearchParamDefaults.security_groups),
     show_hidden: bool = fastapi_query(SearchParamDefaults.show_hidden),
     rank_fusion: RankFusionName = fastapi_query(SearchParamDefaults.rank_fusion),
-    reranker: Union[RerankerName, Reranker] = fastapi_query(SearchParamDefaults.reranker),
+    reranker: RerankerName = fastapi_query(SearchParamDefaults.reranker),
     search_configuration: Optional[str] = Query(
         default=None,
         description="Load find parameters from this configuration. Parameters in the request override parameters from the configuration.",
@@ -166,7 +164,6 @@ async def find_knowledgebox(
             extracted=extracted,
             with_duplicates=with_duplicates,
             with_synonyms=with_synonyms,
-            autofilter=autofilter,
             security=security,
             show_hidden=show_hidden,
             rank_fusion=rank_fusion,

nucliadb/search/api/v1/hydrate.py

@@ -0,0 +1,328 @@
+# 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/>.
+#
+import asyncio
+from typing import Awaitable, Optional, Union
+
+from async_lru import alru_cache
+from fastapi import Request, Response
+from fastapi_versioning import version
+
+from nucliadb.common.ids import FIELD_TYPE_STR_TO_PB, FieldId, ParagraphId
+from nucliadb.ingest.fields.base import Field
+from nucliadb.search.api.v1.router import KB_PREFIX, api
+from nucliadb.search.search import cache
+from nucliadb.search.search.cache import request_caches
+from nucliadb.search.search.hydrator.fields import hydrate_field, page_preview_id
+from nucliadb.search.search.hydrator.images import (
+    download_page_preview,
+)
+from nucliadb.search.search.hydrator.paragraphs import ParagraphIndex, hydrate_paragraph
+from nucliadb.search.search.hydrator.resources import hydrate_resource
+from nucliadb_models.hydration import (
+    Hydrated,
+    HydratedConversationField,
+    HydratedFileField,
+    HydratedGenericField,
+    HydratedLinkField,
+    HydratedParagraph,
+    HydratedResource,
+    HydratedTextField,
+    HydrateRequest,
+    Hydration,
+    ParagraphHydration,
+)
+from nucliadb_models.resource import NucliaDBRoles
+from nucliadb_models.search import Image
+from nucliadb_utils.authentication import requires
+
+
+@api.post(
+    f"/{KB_PREFIX}/{{kbid}}/hydrate",
+    status_code=200,
+    summary="Hydrate a set of paragraphs",
+    description="Internal API endpoint to hydrate a set of paragraphs",
+    include_in_schema=False,
+    response_model_exclude_unset=True,
+    tags=["Hydration"],
+)
+@requires(NucliaDBRoles.READER)
+@version(1)
+async def hydrate_endpoint(
+    request: Request,
+    response: Response,
+    kbid: str,
+    item: HydrateRequest,
+) -> Hydrated:
+    with request_caches():
+        return await Hydrator(kbid, item.hydration).hydrate(item.data)
+
+
+class HydratedBuilder:
+    """Builder class to construct an Hydrated payload."""
+
+    def __init__(self) -> None:
+        self._resources: dict[str, HydratedResource] = {}
+        self._fields: dict[
+            str,
+            Union[
+                HydratedTextField,
+                HydratedFileField,
+                HydratedLinkField,
+                HydratedConversationField,
+                HydratedGenericField,
+            ],
+        ] = {}
+        self._paragraphs: dict[str, HydratedParagraph] = {}
+
+    @property
+    def resources(self) -> dict[str, HydratedResource]:
+        return self._resources
+
+    @property
+    def fields(
+        self,
+    ) -> dict[
+        str,
+        Union[
+            HydratedTextField,
+            HydratedFileField,
+            HydratedLinkField,
+            HydratedConversationField,
+            HydratedGenericField,
+        ],
+    ]:
+        return self._fields
+
+    @property
+    def paragraphs(self) -> dict[str, HydratedParagraph]:
+        return self._paragraphs
+
+    def build(self) -> Hydrated:
+        return Hydrated(
+            resources=self._resources,
+            fields=self._fields,
+            paragraphs=self._paragraphs,
+        )
+
+    def add_resource(self, rid: str, resource: HydratedResource):
+        self._resources[rid] = resource
+
+    def add_field(
+        self,
+        field_id: FieldId,
+        field: Union[
+            HydratedTextField,
+            HydratedFileField,
+            HydratedLinkField,
+            HydratedConversationField,
+            HydratedGenericField,
+        ],
+    ):
+        self._fields[field_id.full()] = field
+
+    def has_field(self, field_id: FieldId) -> bool:
+        return field_id.full() in self._fields
+
+    def add_paragraph(self, paragraph_id: ParagraphId, paragraph: HydratedParagraph):
+        self._paragraphs[paragraph_id.full()] = paragraph
+
+    def add_page_preview(self, paragraph_id: ParagraphId, page: int, image: Image):
+        field_id = paragraph_id.field_id
+        field = self._fields[field_id.full()]
+
+        if not isinstance(field, HydratedFileField):
+            # Other field types have no page preview concept
+            return
+
+        if field.previews is None:
+            field.previews = {}
+
+        preview_id = page_preview_id(page)
+        field.previews[preview_id] = image
+
+        paragraph = self._paragraphs[paragraph_id.full()]
+        assert paragraph.page is not None, "should already be set"
+        paragraph.page.page_preview_ref = preview_id
+
+    def add_table_page_preview(self, paragraph_id: ParagraphId, page: int, image: Image):
+        field_id = paragraph_id.field_id
+        field = self._fields[field_id.full()]
+
+        if not isinstance(field, HydratedFileField):
+            # Other field types have no page preview concept
+            return
+
+        if field.previews is None:
+            field.previews = {}
+
+        preview_id = page_preview_id(page)
+        field.previews[preview_id] = image
+
+        paragraph = self._paragraphs[paragraph_id.full()]
+        assert paragraph.table is not None, "should already be set"
+        paragraph.table.page_preview_ref = preview_id
+
+
+class Hydrator:
+    def __init__(self, kbid: str, config: Hydration):
+        self.kbid = kbid
+        self.config = config
+        self.hydrated = HydratedBuilder()
+
+        # cached paragraphs per field
+        self.field_paragraphs: dict[FieldId, ParagraphIndex] = {}
+
+        self.max_ops = asyncio.Semaphore(50)
+
+    async def hydrate(self, paragraph_ids: list[str]) -> Hydrated:
+        paragraph_tasks = {}
+        field_tasks = {}
+        resource_tasks = {}
+
+        unique_paragraph_ids = set(paragraph_ids)
+        for user_paragraph_id in unique_paragraph_ids:
+            try:
+                paragraph_id = ParagraphId.from_string(user_paragraph_id)
+            except ValueError:
+                # skip paragraphs with invalid format
+                continue
+
+            field_id = paragraph_id.field_id
+            rid = paragraph_id.rid
+
+            resource = await cache.get_resource(self.kbid, rid)
+            if resource is None:
+                # skip resources that aren't in the DB
+                continue
+
+            field_type_pb = FIELD_TYPE_STR_TO_PB[field_id.type]
+            if not (await resource.field_exists(field_type_pb, field_id.key)):
+                # skip a fields that aren't in the DB
+                continue
+            field = await resource.get_field(field_id.key, field_id.pb_type)
+
+            if field_id not in self.field_paragraphs:
+                field_paragraphs_index = ParagraphIndex(field_id)
+                self.field_paragraphs[field_id] = field_paragraphs_index
+            field_paragraphs_index = self.field_paragraphs[field_id]
+
+            paragraph_tasks[paragraph_id] = asyncio.create_task(
+                self._limited_concurrency(
+                    hydrate_paragraph(
+                        resource, field, paragraph_id, self.config.paragraph, field_paragraphs_index
+                    ),
+                )
+            )
+
+            if field_id not in field_tasks:
+                field_tasks[field_id] = asyncio.create_task(
+                    self._limited_concurrency(hydrate_field(resource, field_id, self.config.field))
+                )
+
+            if rid not in resource_tasks:
+                if self.config.resource is not None:
+                    resource_tasks[rid] = asyncio.create_task(
+                        self._limited_concurrency(hydrate_resource(resource, rid, self.config.resource))
+                    )
+
+        ops = [
+            *paragraph_tasks.values(),
+            *field_tasks.values(),
+            *resource_tasks.values(),
+        ]
+        results = await asyncio.gather(*ops)
+        hydrated_paragraphs = results[: len(paragraph_tasks)]
+        hydrated_fields = results[len(paragraph_tasks) : len(paragraph_tasks) + len(field_tasks)]
+        hydrated_resources = results[
+            len(paragraph_tasks) + len(field_tasks) : len(paragraph_tasks)
+            + len(field_tasks)
+            + len(resource_tasks)
+        ]
+
+        for rid, hydrated_resource in zip(resource_tasks.keys(), hydrated_resources):
+            self.hydrated.add_resource(rid, hydrated_resource)
+
+        for field_id, hydrated_field in zip(field_tasks.keys(), hydrated_fields):
+            if hydrated_field is not None:
+                self.hydrated.add_field(field_id, hydrated_field)
+
+        for paragraph_id, (hydrated_paragraph, extra) in zip(
+            paragraph_tasks.keys(), hydrated_paragraphs
+        ):
+            self.hydrated.add_paragraph(paragraph_id, hydrated_paragraph)
+
+            for related_paragraph_id in extra.related_paragraph_ids:
+                field_id = related_paragraph_id.field_id
+                rid = related_paragraph_id.rid
+
+                resource = await cache.get_resource(self.kbid, rid)
+                if resource is None:
+                    # skip resources that aren't in the DB
+                    continue
+
+                field_type_pb = FIELD_TYPE_STR_TO_PB[field_id.type]
+                if not (await resource.field_exists(field_type_pb, field_id.key)):
+                    # skip a fields that aren't in the DB
+                    continue
+                field = await resource.get_field(field_id.key, field_id.pb_type)
+
+                if field_id not in self.field_paragraphs:
+                    field_paragraphs_index = ParagraphIndex(field_id)
+                    self.field_paragraphs[field_id] = field_paragraphs_index
+                field_paragraphs_index = self.field_paragraphs[field_id]
+
+                (hydrated_paragraph, _) = await hydrate_paragraph(
+                    resource,
+                    field,
+                    related_paragraph_id,
+                    ParagraphHydration(
+                        text=self.config.paragraph.text, image=None, table=None, page=None, related=None
+                    ),
+                    field_paragraphs_index,
+                )
+                self.hydrated.add_paragraph(related_paragraph_id, hydrated_paragraph)
+
+            if self.hydrated.has_field(field_id):
+                # we only hydrate page and table previews for fields the user
+                # allowed hydration, skipping fields with explicitly disabled
+                # hydration
+
+                if extra.field_page is not None:
+                    page_number = extra.field_page
+                    preview = await self.cached_download_page_preview(field, page_number)
+                    if preview is not None:
+                        self.hydrated.add_page_preview(paragraph_id, page_number, preview)
+
+                if extra.field_table_page is not None:
+                    page_number = extra.field_table_page
+                    preview = await self.cached_download_page_preview(field, page_number)
+                    if preview is not None:
+                        self.hydrated.add_table_page_preview(paragraph_id, page_number, preview)
+
+        return self.hydrated.build()
+
+    # TODO: proper typing
+    async def _limited_concurrency(self, aw: Awaitable):
+        async with self.max_ops:
+            return await aw
+
+    @alru_cache(maxsize=None)
+    async def cached_download_page_preview(self, field: Field, page: int) -> Optional[Image]:
+        return await download_page_preview(field, page)

nucliadb/search/api/v1/resource/ask.py

@@ -28,7 +28,8 @@ from nucliadb.search.api.v1.resource.utils import get_resource_uuid_by_slug
 from nucliadb.search.api.v1.router import KB_PREFIX, RESOURCE_SLUG_PREFIX, api
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.search import AskRequest, NucliaDBClientType, SyncAskResponse
-from nucliadb_utils.authentication import requires
+from nucliadb_models.security import RequestSecurity
+from nucliadb_utils.authentication import NucliaUser, requires
 
 from ..ask import create_ask_response
 
@@ -58,6 +59,15 @@ async def resource_ask_endpoint_by_uuid(
         "This is slower and requires waiting for entire answer to be ready.",
     ),
 ) -> Union[StreamingResponse, HTTPClientError, Response]:
+    current_user: NucliaUser = request.user
+    # If present, security groups from AuthorizationBackend overrides any
+    # security group of the payload
+    if current_user.security_groups:
+        if item.security is None:
+            item.security = RequestSecurity(groups=current_user.security_groups)
+        else:
+            item.security.groups = current_user.security_groups
+
     return await create_ask_response(
         kbid=kbid,
         ask_request=item,
@@ -98,6 +108,16 @@ async def resource_ask_endpoint_by_slug(
     resource_id = await get_resource_uuid_by_slug(kbid, slug)
     if resource_id is None:
         return HTTPClientError(status_code=404, detail="Resource not found")
+
+    current_user: NucliaUser = request.user
+    # If present, security groups from AuthorizationBackend overrides any
+    # security group of the payload
+    if current_user.security_groups:
+        if item.security is None:
+            item.security = RequestSecurity(groups=current_user.security_groups)
+        else:
+            item.security.groups = current_user.security_groups
+
     return await create_ask_response(
         kbid=kbid,
         ask_request=item,

nucliadb/search/api/v1/search.py

@@ -148,7 +148,6 @@ async def search_knowledgebox(
     extracted: list[ExtractedDataTypeName] = fastapi_query(SearchParamDefaults.extracted),
     with_duplicates: bool = fastapi_query(SearchParamDefaults.with_duplicates),
     with_synonyms: bool = fastapi_query(SearchParamDefaults.with_synonyms),
-    autofilter: bool = fastapi_query(SearchParamDefaults.autofilter),
     security_groups: list[str] = fastapi_query(SearchParamDefaults.security_groups),
     show_hidden: bool = fastapi_query(SearchParamDefaults.show_hidden),
     x_ndb_client: NucliaDBClientType = Header(NucliaDBClientType.API),
@@ -187,7 +186,6 @@ async def search_knowledgebox(
             extracted=extracted,
             with_duplicates=with_duplicates,
             with_synonyms=with_synonyms,
-            autofilter=autofilter,
             security=security,
             show_hidden=show_hidden,
         )
@@ -262,7 +260,7 @@ async def search(
     start_time = time()
 
     parsed = await parse_search(kbid, item)
-    pb_query, incomplete_results, autofilters, _ = await legacy_convert_retrieval_to_proto(parsed)
+    pb_query, incomplete_results, _ = await legacy_convert_retrieval_to_proto(parsed)
 
     # We need to query all nodes
     results, queried_shards = await nidx_query(kbid, Method.SEARCH, pb_query)
@@ -290,5 +288,4 @@ async def search(
         )
 
     search_results.shards = queried_shards
-    search_results.autofilters = autofilters
     return search_results, incomplete_results

nucliadb/search/predict.py

@@ -447,6 +447,10 @@ class DummyPredictEngine(PredictEngine):
         self.cluster_url = "http://localhost:8000"
         self.public_url = "http://localhost:8000"
         self.calls = []
+        self.ndjson_reasoning = [
+            b'{"chunk": {"type": "reasoning", "text": "dummy "}}\n',
+            b'{"chunk": {"type": "reasoning", "text": "reasoning"}}\n',
+        ]
         self.ndjson_answer = [
             b'{"chunk": {"type": "text", "text": "valid "}}\n',
             b'{"chunk": {"type": "text", "text": "answer "}}\n',
@@ -482,8 +486,11 @@ class DummyPredictEngine(PredictEngine):
         self.calls.append(("chat_query_ndjson", item))
 
         async def generate():
-            for item in self.ndjson_answer:
-                yield GenerativeChunk.model_validate_json(item)
+            if item.reasoning is not False:
+                for chunk in self.ndjson_reasoning:
+                    yield GenerativeChunk.model_validate_json(chunk)
+            for chunk in self.ndjson_answer:
+                yield GenerativeChunk.model_validate_json(chunk)
 
         return (DUMMY_LEARNING_ID, DUMMY_LEARNING_MODEL, generate())
 

nucliadb/search/search/cache.py

@@ -21,8 +21,6 @@ import contextlib
 import logging
 from typing import Optional
 
-import backoff
-
 from nucliadb.common.cache import (
     extracted_text_cache,
     get_extracted_text_cache,
@@ -54,7 +52,7 @@ async def get_resource(kbid: str, uuid: str) -> Optional[ResourceORM]:
 
 
 async def _orm_get_resource(kbid: str, uuid: str) -> Optional[ResourceORM]:
-    async with get_driver().transaction(read_only=True) as txn:
+    async with get_driver().ro_transaction() as txn:
         storage = await get_storage(service_name=SERVICE_NAME)
         kb = KnowledgeBoxORM(txn, storage, kbid)
         return await kb.get(uuid)
@@ -74,23 +72,6 @@ async def get_field_extracted_text(field: Field) -> Optional[ExtractedText]:
     return extracted_text
 
 
-@backoff.on_exception(backoff.expo, (Exception,), jitter=backoff.random_jitter, max_tries=3)
-async def field_get_extracted_text(field: Field) -> Optional[ExtractedText]:
-    try:
-        return await field.get_extracted_text()
-    except Exception:
-        logger.warning(
-            "Error getting extracted text for field. Retrying",
-            exc_info=True,
-            extra={
-                "kbid": field.kbid,
-                "resource_id": field.resource.uuid,
-                "field": f"{field.type}/{field.id}",
-            },
-        )
-        raise
-
-
 async def get_extracted_text_from_field_id(kbid: str, field: FieldId) -> Optional[ExtractedText]:
     rid = field.rid
     orm_resource = await get_resource(kbid, rid)