nucliadb 6.7.2.post4874__py3-none-any.whl → 6.10.0.post5705__py3-none-any.whl

nucliadb/search/api/v1/find.py

@@ -18,7 +18,6 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import json
-from typing import Optional, Union
 
 from fastapi import Body, Header, Query, Request, Response
 from fastapi.openapi.models import Example
@@ -46,7 +45,6 @@ from nucliadb_models.search import (
     KnowledgeboxFindResults,
     NucliaDBClientType,
     RankFusionName,
-    Reranker,
     RerankerName,
     ResourceProperties,
     SearchParamDefaults,
@@ -84,33 +82,31 @@ async def find_knowledgebox(
     response: Response,
     kbid: str,
     query: str = fastapi_query(SearchParamDefaults.query),
-    filter_expression: Optional[str] = fastapi_query(SearchParamDefaults.filter_expression),
+    filter_expression: str | None = fastapi_query(SearchParamDefaults.filter_expression),
     fields: list[str] = fastapi_query(SearchParamDefaults.fields),
     filters: list[str] = fastapi_query(SearchParamDefaults.filters),
-    top_k: Optional[int] = fastapi_query(SearchParamDefaults.top_k),
-    min_score: Optional[float] = Query(
+    top_k: int | None = fastapi_query(SearchParamDefaults.top_k),
+    min_score: float | None = Query(
         default=None,
-        description="Minimum similarity score to filter vector index results. If not specified, the default minimum score of the semantic model associated to the Knowledge Box will be used. Check out the documentation for more information on how to use this parameter: https://docs.nuclia.dev/docs/rag/advanced/search#minimum-score",  # noqa: E501
+        description="Minimum similarity score to filter vector index results. If not specified, the default minimum score of the semantic model associated to the Knowledge Box will be used. Check out the documentation for more information on how to use this parameter: https://docs.nuclia.dev/docs/rag/advanced/search#minimum-score",
         deprecated=True,
     ),
-    min_score_semantic: Optional[float] = Query(
+    min_score_semantic: float | None = Query(
         default=None,
-        description="Minimum semantic similarity score to filter vector index results. If not specified, the default minimum score of the semantic model associated to the Knowledge Box will be used. Check out the documentation for more information on how to use this parameter: https://docs.nuclia.dev/docs/rag/advanced/search#minimum-score",  # noqa: E501
+        description="Minimum semantic similarity score to filter vector index results. If not specified, the default minimum score of the semantic model associated to the Knowledge Box will be used. Check out the documentation for more information on how to use this parameter: https://docs.nuclia.dev/docs/rag/advanced/search#minimum-score",
     ),
     min_score_bm25: float = Query(
         default=0,
         description="Minimum bm25 score to filter paragraph and document index results",
         ge=0,
     ),
-    vectorset: Optional[str] = fastapi_query(SearchParamDefaults.vectorset),
-    range_creation_start: Optional[DateTime] = fastapi_query(SearchParamDefaults.range_creation_start),
-    range_creation_end: Optional[DateTime] = fastapi_query(SearchParamDefaults.range_creation_end),
-    range_modification_start: Optional[DateTime] = fastapi_query(
+    vectorset: str | None = fastapi_query(SearchParamDefaults.vectorset),
+    range_creation_start: DateTime | None = fastapi_query(SearchParamDefaults.range_creation_start),
+    range_creation_end: DateTime | None = fastapi_query(SearchParamDefaults.range_creation_end),
+    range_modification_start: DateTime | None = fastapi_query(
         SearchParamDefaults.range_modification_start
     ),
-    range_modification_end: Optional[DateTime] = fastapi_query(
-        SearchParamDefaults.range_modification_end
-    ),
+    range_modification_end: DateTime | None = fastapi_query(SearchParamDefaults.range_modification_end),
     features: list[FindOptions] = fastapi_query(
         SearchParamDefaults.search_features,
         default=[
@@ -127,19 +123,18 @@ 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),
-    search_configuration: Optional[str] = Query(
+    reranker: RerankerName = fastapi_query(SearchParamDefaults.reranker),
+    search_configuration: str | None = Query(
         default=None,
         description="Load find parameters from this configuration. Parameters in the request override parameters from the configuration.",
     ),
     x_ndb_client: NucliaDBClientType = Header(NucliaDBClientType.API),
     x_nucliadb_user: str = Header(""),
     x_forwarded_for: str = Header(""),
-) -> Union[KnowledgeboxFindResults, HTTPClientError]:
+) -> KnowledgeboxFindResults | HTTPClientError:
     try:
         expr = FilterExpression.model_validate_json(filter_expression) if filter_expression else None
 
@@ -166,7 +161,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,
@@ -198,7 +192,7 @@ async def find_post_knowledgebox(
     x_ndb_client: NucliaDBClientType = Header(NucliaDBClientType.API),
     x_nucliadb_user: str = Header(""),
     x_forwarded_for: str = Header(""),
-) -> Union[KnowledgeboxFindResults, HTTPClientError]:
+) -> KnowledgeboxFindResults | HTTPClientError:
     return await _find_endpoint(response, kbid, item, x_ndb_client, x_nucliadb_user, x_forwarded_for)
 
 
@@ -209,7 +203,7 @@ async def _find_endpoint(
     x_ndb_client: NucliaDBClientType,
     x_nucliadb_user: str,
     x_forwarded_for: str,
-) -> Union[KnowledgeboxFindResults, HTTPClientError]:
+) -> KnowledgeboxFindResults | HTTPClientError:
     if item.search_configuration is not None:
         search_config = await datamanagers.atomic.search_configurations.get(
             kbid=kbid, name=item.search_configuration

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 collections.abc import Awaitable
+
+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,
+            (
+                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,
+        (
+            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: (
+            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(field, 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=50)
+    async def cached_download_page_preview(self, field: Field, page: int) -> Image | None:
+        return await download_page_preview(field, page)

nucliadb/search/api/v1/knowledgebox.py

@@ -18,7 +18,6 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import asyncio
-from typing import Optional
 
 from fastapi import HTTPException, Request
 from fastapi_versioning import version
@@ -178,7 +177,7 @@ async def get_node_index_counts(kbid: str) -> tuple[IndexCounts, list[str]]:
         )
 
     try:
-        results: Optional[list[Shard]] = await asyncio.wait_for(
+        results: list[Shard] | None = await asyncio.wait_for(
             asyncio.gather(*ops, return_exceptions=True),  # type: ignore
             timeout=settings.search_timeout,
         )

nucliadb/search/api/v1/predict_proxy.py

@@ -18,7 +18,6 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import json
-from typing import Union
 
 from fastapi import Header, Request
 from fastapi.responses import Response, StreamingResponse
@@ -68,7 +67,7 @@ async def predict_proxy_endpoint(
     x_nucliadb_user: str = Header(""),
     x_ndb_client: NucliaDBClientType = Header(NucliaDBClientType.API),
     x_forwarded_for: str = Header(""),
-) -> Union[Response, StreamingResponse, HTTPClientError]:
+) -> Response | StreamingResponse | HTTPClientError:
     try:
         payload = await request.json()
     except json.JSONDecodeError:

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

@@ -17,18 +17,19 @@
 # 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 Union
+from uuid import UUID
 
 from fastapi import Header, Request, Response
 from fastapi_versioning import version
 from starlette.responses import StreamingResponse
 
+from nucliadb.common import datamanagers
 from nucliadb.models.responses import HTTPClientError
-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
 
@@ -46,7 +47,7 @@ from ..ask import create_ask_response
 async def resource_ask_endpoint_by_uuid(
     request: Request,
     kbid: str,
-    rid: str,
+    rid: UUID,
     item: AskRequest,
     x_show_consumption: bool = Header(default=False),
     x_ndb_client: NucliaDBClientType = Header(NucliaDBClientType.API),
@@ -57,7 +58,16 @@ async def resource_ask_endpoint_by_uuid(
         description="When set to true, outputs response as JSON in a non-streaming way. "
         "This is slower and requires waiting for entire answer to be ready.",
     ),
-) -> Union[StreamingResponse, HTTPClientError, Response]:
+) -> 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,
@@ -65,7 +75,7 @@ async def resource_ask_endpoint_by_uuid(
         client_type=x_ndb_client,
         origin=x_forwarded_for,
         x_synchronous=x_synchronous,
-        resource=rid,
+        resource=str(rid),
         extra_predict_headers={"X-Show-Consumption": str(x_show_consumption).lower()},
     )
 
@@ -94,10 +104,20 @@ async def resource_ask_endpoint_by_slug(
         description="When set to true, outputs response as JSON in a non-streaming way. "
         "This is slower and requires waiting for entire answer to be ready.",
     ),
-) -> Union[StreamingResponse, HTTPClientError, Response]:
-    resource_id = await get_resource_uuid_by_slug(kbid, slug)
+) -> StreamingResponse | HTTPClientError | Response:
+    resource_id = await datamanagers.atomic.resources.get_resource_uuid_from_slug(kbid=kbid, slug=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/resource/ingestion_agents.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 Union
 
 from fastapi import Header, Request, Response
 from fastapi_versioning import version
 
+from nucliadb.common import datamanagers
 from nucliadb.common.models_utils import from_proto
 from nucliadb.models.responses import HTTPClientError
-from nucliadb.search.api.v1.resource.utils import get_resource_uuid_by_slug
 from nucliadb.search.api.v1.router import KB_PREFIX, RESOURCE_PREFIX, RESOURCE_SLUG_PREFIX, api
 from nucliadb.search.predict_models import AugmentedField, RunAgentsResponse
 from nucliadb.search.search.exceptions import ResourceNotFoundError
@@ -58,7 +57,7 @@ async def run_agents_by_uuid(
     rid: str,
     item: ResourceAgentsRequest,
     x_nucliadb_user: str = Header(""),
-) -> Union[ResourceAgentsResponse, HTTPClientError]:
+) -> ResourceAgentsResponse | HTTPClientError:
     return await _run_agents_endpoint(kbid, rid, x_nucliadb_user, item)
 
 
@@ -80,8 +79,8 @@ async def run_agents_by_slug(
     slug: str,
     item: ResourceAgentsRequest,
     x_nucliadb_user: str = Header(""),
-) -> Union[ResourceAgentsResponse, HTTPClientError]:
-    resource_id = await get_resource_uuid_by_slug(kbid, slug)
+) -> ResourceAgentsResponse | HTTPClientError:
+    resource_id = await datamanagers.atomic.resources.get_resource_uuid_from_slug(kbid=kbid, slug=slug)
     if resource_id is None:
         return HTTPClientError(status_code=404, detail="Resource not found")
     return await _run_agents_endpoint(kbid, resource_id, x_nucliadb_user, item)
@@ -89,7 +88,7 @@ async def run_agents_by_slug(
 
 async def _run_agents_endpoint(
     kbid: str, resource_id: str, user_id: str, item: ResourceAgentsRequest
-) -> Union[ResourceAgentsResponse, HTTPClientError]:
+) -> ResourceAgentsResponse | HTTPClientError:
     try:
         run_agents_response: RunAgentsResponse = await run_agents(
             kbid,

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

@@ -18,7 +18,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import json
-from typing import Optional, Union, cast
+from typing import cast
 
 from fastapi import Header, Request, Response
 from fastapi_versioning import version
@@ -62,25 +62,23 @@ async def resource_search(
     kbid: str,
     query: str,
     rid: str,
-    filter_expression: Optional[str] = fastapi_query(SearchParamDefaults.filter_expression),
+    filter_expression: str | None = fastapi_query(SearchParamDefaults.filter_expression),
     fields: list[str] = fastapi_query(SearchParamDefaults.fields),
     filters: list[str] = fastapi_query(SearchParamDefaults.filters),
     faceted: list[str] = fastapi_query(SearchParamDefaults.faceted),
-    sort: Optional[SortField] = fastapi_query(SearchParamDefaults.sort_field, alias="sort_field"),
+    sort: SortField | None = fastapi_query(SearchParamDefaults.sort_field, alias="sort_field"),
     sort_order: SortOrder = fastapi_query(SearchParamDefaults.sort_order),
-    top_k: Optional[int] = fastapi_query(SearchParamDefaults.top_k),
-    range_creation_start: Optional[DateTime] = fastapi_query(SearchParamDefaults.range_creation_start),
-    range_creation_end: Optional[DateTime] = fastapi_query(SearchParamDefaults.range_creation_end),
-    range_modification_start: Optional[DateTime] = fastapi_query(
+    top_k: int | None = fastapi_query(SearchParamDefaults.top_k),
+    range_creation_start: DateTime | None = fastapi_query(SearchParamDefaults.range_creation_start),
+    range_creation_end: DateTime | None = fastapi_query(SearchParamDefaults.range_creation_end),
+    range_modification_start: DateTime | None = fastapi_query(
         SearchParamDefaults.range_modification_start
     ),
-    range_modification_end: Optional[DateTime] = fastapi_query(
-        SearchParamDefaults.range_modification_end
-    ),
+    range_modification_end: DateTime | None = fastapi_query(SearchParamDefaults.range_modification_end),
     highlight: bool = fastapi_query(SearchParamDefaults.highlight),
     x_ndb_client: NucliaDBClientType = Header(NucliaDBClientType.API),
     debug: bool = fastapi_query(SearchParamDefaults.debug),
-) -> Union[ResourceSearchResults, HTTPClientError]:
+) -> ResourceSearchResults | HTTPClientError:
     top_k = top_k or SearchParamDefaults.top_k  # type: ignore
     top_k = cast(int, top_k)