nucliadb 6.1.0.post2594__py3-none-any.whl → 6.1.0.post2610__py3-none-any.whl

nucliadb/search/api/v1/__init__.py

@@ -18,6 +18,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 from . import ask  # noqa
+from . import catalog  # noqa
 from . import feedback  # noqa
 from . import find  # noqa
 from . import knowledgebox  # noqa

nucliadb/search/api/v1/catalog.py

@@ -0,0 +1,184 @@
+# 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 time import time
+from typing import Optional, Union
+
+from fastapi import Request, Response
+from fastapi_versioning import version
+
+from nucliadb.common.datamanagers.exceptions import KnowledgeBoxNotFound
+from nucliadb.common.maindb.pg import PGDriver
+from nucliadb.common.maindb.utils import get_driver
+from nucliadb.models.responses import HTTPClientError
+from nucliadb.search import logger
+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.exceptions import InvalidQueryError
+from nucliadb.search.search.merge import fetch_resources
+from nucliadb.search.search.pgcatalog import pgcatalog_search
+from nucliadb.search.search.query_parser.parser import parse_catalog
+from nucliadb.search.search.utils import (
+    maybe_log_request_payload,
+)
+from nucliadb_models.common import FieldTypeName
+from nucliadb_models.metadata import ResourceProcessingStatus
+from nucliadb_models.resource import NucliaDBRoles
+from nucliadb_models.search import (
+    CatalogRequest,
+    CatalogResponse,
+    KnowledgeboxSearchResults,
+    ResourceProperties,
+    SearchParamDefaults,
+    SortField,
+    SortOptions,
+    SortOrder,
+)
+from nucliadb_models.utils import DateTime
+from nucliadb_utils.authentication import requires
+from nucliadb_utils.exceptions import LimitsExceededError
+
+
+@api.get(
+    f"/{KB_PREFIX}/{{kbid}}/catalog",
+    status_code=200,
+    summary="List resources of a Knowledge Box",
+    description="List resources of a Knowledge Box",
+    response_model=KnowledgeboxSearchResults,
+    response_model_exclude_unset=True,
+    tags=["Search"],
+)
+@requires(NucliaDBRoles.READER)
+@version(1)
+async def catalog_get(
+    request: Request,
+    response: Response,
+    kbid: str,
+    query: str = fastapi_query(SearchParamDefaults.query),
+    filters: list[str] = fastapi_query(SearchParamDefaults.filters),
+    faceted: list[str] = fastapi_query(SearchParamDefaults.faceted),
+    sort_field: SortField = fastapi_query(SearchParamDefaults.sort_field),
+    sort_limit: Optional[int] = fastapi_query(SearchParamDefaults.sort_limit),
+    sort_order: SortOrder = fastapi_query(SearchParamDefaults.sort_order),
+    page_number: int = fastapi_query(SearchParamDefaults.catalog_page_number),
+    page_size: int = fastapi_query(SearchParamDefaults.catalog_page_size),
+    shards: list[str] = fastapi_query(SearchParamDefaults.shards, deprecated=True),
+    with_status: Optional[ResourceProcessingStatus] = fastapi_query(
+        SearchParamDefaults.with_status, deprecated="Use filters instead"
+    ),
+    debug: bool = fastapi_query(SearchParamDefaults.debug, include_in_schema=False),
+    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(
+        SearchParamDefaults.range_modification_start
+    ),
+    range_modification_end: Optional[DateTime] = fastapi_query(
+        SearchParamDefaults.range_modification_end
+    ),
+    hidden: Optional[bool] = fastapi_query(SearchParamDefaults.hidden),
+) -> Union[KnowledgeboxSearchResults, HTTPClientError]:
+    item = CatalogRequest(
+        query=query,
+        filters=filters,
+        faceted=faceted,
+        page_number=page_number,
+        page_size=page_size,
+        shards=shards,
+        debug=debug,
+        with_status=with_status,
+        range_creation_start=range_creation_start,
+        range_creation_end=range_creation_end,
+        range_modification_start=range_modification_start,
+        range_modification_end=range_modification_end,
+        hidden=hidden,
+    )
+    if sort_field:
+        item.sort = SortOptions(field=sort_field, limit=sort_limit, order=sort_order)
+    return await catalog(kbid, item)
+
+
+@api.post(
+    f"/{KB_PREFIX}/{{kbid}}/catalog",
+    status_code=200,
+    summary="List resources of a Knowledge Box",
+    description="List resources of a Knowledge Box",
+    response_model=KnowledgeboxSearchResults,
+    response_model_exclude_unset=True,
+    tags=["Search"],
+)
+@requires(NucliaDBRoles.READER)
+@version(1)
+async def catalog_post(
+    request: Request,
+    kbid: str,
+    item: CatalogRequest,
+) -> Union[CatalogResponse, HTTPClientError]:
+    return await catalog(kbid, item)
+
+
+async def catalog(
+    kbid: str,
+    item: CatalogRequest,
+):
+    """
+    Catalog endpoint is a simplified version of the search endpoint, it only
+    returns bm25 results on titles and it does not support vector search.
+    It is useful for listing resources in a knowledge box.
+    """
+    if not pgcatalog_enabled():  # pragma: no cover
+        return HTTPClientError(status_code=501, detail="PG driver is needed for catalog search")
+
+    maybe_log_request_payload(kbid, "/catalog", item)
+    start_time = time()
+    try:
+        with cache.request_caches():
+            query_parser = parse_catalog(kbid, item)
+
+            catalog_results = CatalogResponse()
+            catalog_results.fulltext = await pgcatalog_search(query_parser)
+            catalog_results.resources = await fetch_resources(
+                resources=[r.rid for r in catalog_results.fulltext.results],
+                kbid=kbid,
+                show=[ResourceProperties.BASIC, ResourceProperties.ERRORS],
+                field_type_filter=list(FieldTypeName),
+                extracted=[],
+            )
+            return catalog_results
+    except InvalidQueryError as exc:
+        return HTTPClientError(status_code=412, detail=str(exc))
+    except KnowledgeBoxNotFound:
+        return HTTPClientError(status_code=404, detail="Knowledge Box not found")
+    except LimitsExceededError as exc:
+        return HTTPClientError(status_code=exc.status_code, detail=exc.detail)
+    finally:
+        duration = time() - start_time
+        if duration > 2:  # pragma: no cover
+            logger.warning(
+                "Slow catalog request",
+                extra={
+                    "kbid": kbid,
+                    "duration": duration,
+                    "query": item.model_dump_json(),
+                },
+            )
+
+
+def pgcatalog_enabled():
+    return isinstance(get_driver(), PGDriver)

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

@@ -90,7 +90,6 @@ async def resource_search(
                 fields,
                 filters,
                 faceted,
-                0,
                 top_k,
                 range_creation_start,
                 range_creation_end,
@@ -109,8 +108,7 @@ async def resource_search(
         # We need to merge
         search_results = await merge_paragraphs_results(
             results,
-            count=top_k,
-            page=0,
+            top_k=top_k,
             kbid=kbid,
             highlight_split=highlight,
             min_score=0.0,

nucliadb/search/api/v1/search.py

@@ -27,21 +27,17 @@ from fastapi_versioning import version
 from pydantic import ValidationError
 
 from nucliadb.common.datamanagers.exceptions import KnowledgeBoxNotFound
-from nucliadb.common.maindb.pg import PGDriver
-from nucliadb.common.maindb.utils import get_driver
 from nucliadb.models.responses import HTTPClientError
-from nucliadb.search import logger, predict
+from nucliadb.search import predict
 from nucliadb.search.api.v1.router import KB_PREFIX, api
 from nucliadb.search.api.v1.utils import fastapi_query
 from nucliadb.search.requesters.utils import Method, debug_nodes_info, node_query
 from nucliadb.search.search import cache
 from nucliadb.search.search.exceptions import InvalidQueryError
-from nucliadb.search.search.merge import fetch_resources, merge_results
-from nucliadb.search.search.pgcatalog import pgcatalog_search
+from nucliadb.search.search.merge import merge_results
 from nucliadb.search.search.query import QueryParser
 from nucliadb.search.search.utils import (
     filter_hidden_resources,
-    maybe_log_request_payload,
     min_score_from_payload,
     min_score_from_query_params,
     should_disable_vector_search,
@@ -50,10 +46,7 @@ from nucliadb_models.common import FieldTypeName
 from nucliadb_models.metadata import ResourceProcessingStatus
 from nucliadb_models.resource import ExtractedDataTypeName, NucliaDBRoles
 from nucliadb_models.search import (
-    CatalogRequest,
-    CatalogResponse,
     KnowledgeboxSearchResults,
-    MinScore,
     NucliaDBClientType,
     ResourceProperties,
     SearchOptions,
@@ -202,156 +195,6 @@ async def search_knowledgebox(
     return await _search_endpoint(response, kbid, item, x_ndb_client, x_nucliadb_user, x_forwarded_for)
 
 
-@api.get(
-    f"/{KB_PREFIX}/{{kbid}}/catalog",
-    status_code=200,
-    summary="List resources of a Knowledge Box",
-    description="List resources of a Knowledge Box",
-    response_model=KnowledgeboxSearchResults,
-    response_model_exclude_unset=True,
-    tags=["Search"],
-)
-@requires(NucliaDBRoles.READER)
-@version(1)
-async def catalog_get(
-    request: Request,
-    response: Response,
-    kbid: str,
-    query: str = fastapi_query(SearchParamDefaults.query),
-    filters: list[str] = fastapi_query(SearchParamDefaults.filters),
-    faceted: list[str] = fastapi_query(SearchParamDefaults.faceted),
-    sort_field: SortField = fastapi_query(SearchParamDefaults.sort_field),
-    sort_limit: Optional[int] = fastapi_query(SearchParamDefaults.sort_limit),
-    sort_order: SortOrder = fastapi_query(SearchParamDefaults.sort_order),
-    page_number: int = fastapi_query(SearchParamDefaults.catalog_page_number),
-    page_size: int = fastapi_query(SearchParamDefaults.catalog_page_size),
-    shards: list[str] = fastapi_query(SearchParamDefaults.shards, deprecated=True),
-    with_status: Optional[ResourceProcessingStatus] = fastapi_query(
-        SearchParamDefaults.with_status, deprecated="Use filters instead"
-    ),
-    debug: bool = fastapi_query(SearchParamDefaults.debug, include_in_schema=False),
-    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(
-        SearchParamDefaults.range_modification_start
-    ),
-    range_modification_end: Optional[DateTime] = fastapi_query(
-        SearchParamDefaults.range_modification_end
-    ),
-    hidden: Optional[bool] = fastapi_query(SearchParamDefaults.hidden),
-) -> Union[KnowledgeboxSearchResults, HTTPClientError]:
-    item = CatalogRequest(
-        query=query,
-        filters=filters,
-        faceted=faceted,
-        page_number=page_number,
-        page_size=page_size,
-        shards=shards,
-        debug=debug,
-        with_status=with_status,
-        range_creation_start=range_creation_start,
-        range_creation_end=range_creation_end,
-        range_modification_start=range_modification_start,
-        range_modification_end=range_modification_end,
-        hidden=hidden,
-    )
-    if sort_field:
-        item.sort = SortOptions(field=sort_field, limit=sort_limit, order=sort_order)
-    return await catalog(kbid, item)
-
-
-@api.post(
-    f"/{KB_PREFIX}/{{kbid}}/catalog",
-    status_code=200,
-    summary="List resources of a Knowledge Box",
-    description="List resources of a Knowledge Box",
-    response_model=KnowledgeboxSearchResults,
-    response_model_exclude_unset=True,
-    tags=["Search"],
-)
-@requires(NucliaDBRoles.READER)
-@version(1)
-async def catalog_post(
-    request: Request,
-    kbid: str,
-    item: CatalogRequest,
-) -> Union[CatalogResponse, HTTPClientError]:
-    return await catalog(kbid, item)
-
-
-async def catalog(
-    kbid: str,
-    item: CatalogRequest,
-):
-    """
-    Catalog endpoint is a simplified version of the search endpoint, it only
-    returns bm25 results on titles and it does not support vector search.
-    It is useful for listing resources in a knowledge box.
-    """
-    if not pgcatalog_enabled():  # pragma: no cover
-        return HTTPClientError(status_code=501, detail="PG driver is needed for catalog search")
-
-    maybe_log_request_payload(kbid, "/catalog", item)
-    start_time = time()
-    try:
-        with cache.request_caches():
-            sort = item.sort
-            if sort is None:
-                # By default we sort by creation date (most recent first)
-                sort = SortOptions(
-                    field=SortField.CREATED,
-                    order=SortOrder.DESC,
-                    limit=None,
-                )
-
-            query_parser = QueryParser(
-                kbid=kbid,
-                features=[SearchOptions.FULLTEXT],
-                query=item.query,
-                label_filters=item.filters,
-                keyword_filters=[],
-                faceted=item.faceted,
-                sort=sort,
-                page_number=item.page_number,
-                page_size=item.page_size,
-                min_score=MinScore(bm25=0, semantic=0),
-                fields=["a/title"],
-                with_status=item.with_status,
-                range_creation_start=item.range_creation_start,
-                range_creation_end=item.range_creation_end,
-                range_modification_start=item.range_modification_start,
-                range_modification_end=item.range_modification_end,
-                hidden=item.hidden,
-            )
-            catalog_results = CatalogResponse()
-            catalog_results.fulltext = await pgcatalog_search(query_parser)
-            catalog_results.resources = await fetch_resources(
-                resources=[r.rid for r in catalog_results.fulltext.results],
-                kbid=kbid,
-                show=[ResourceProperties.BASIC, ResourceProperties.ERRORS],
-                field_type_filter=list(FieldTypeName),
-                extracted=[],
-            )
-            return catalog_results
-    except InvalidQueryError as exc:
-        return HTTPClientError(status_code=412, detail=str(exc))
-    except KnowledgeBoxNotFound:
-        return HTTPClientError(status_code=404, detail="Knowledge Box not found")
-    except LimitsExceededError as exc:
-        return HTTPClientError(status_code=exc.status_code, detail=exc.detail)
-    finally:
-        duration = time() - start_time
-        if duration > 2:  # pragma: no cover
-            logger.warning(
-                "Slow catalog request",
-                extra={
-                    "kbid": kbid,
-                    "duration": duration,
-                    "query": item.model_dump_json(),
-                },
-            )
-
-
 @api.post(
     f"/{KB_PREFIX}/{{kbid}}/search",
     status_code=200,
@@ -431,8 +274,7 @@ async def search(
         keyword_filters=[],
         faceted=item.faceted,
         sort=item.sort,
-        page_number=0,
-        page_size=item.top_k,
+        top_k=item.top_k,
         min_score=item.min_score,
         range_creation_start=item.range_creation_start,
         range_creation_end=item.range_creation_end,
@@ -461,8 +303,7 @@ async def search(
     # We need to merge
     search_results = await merge_results(
         results,
-        count=item.top_k,
-        page=0,
+        top_k=item.top_k,
         kbid=kbid,
         show=item.show,
         field_type_filter=item.field_type_filter,
@@ -491,7 +332,3 @@ async def search(
     search_results.shards = queried_shards
     search_results.autofilters = autofilters
     return search_results, incomplete_results
-
-
-def pgcatalog_enabled():
-    return isinstance(get_driver(), PGDriver)

nucliadb/search/search/chat/ask.py

@@ -721,8 +721,7 @@ async def retrieval_in_resource(
                 query="",
                 label_filters=ask_request.filters,
                 keyword_filters=ask_request.keyword_filters,
-                page_number=0,
-                page_size=0,
+                top_k=0,
                 min_score=MinScore(),
             ),
             main_query_weight=1.0,

nucliadb/search/search/cut.py

@@ -23,10 +23,8 @@ from typing import TypeVar
 T = TypeVar("T")
 
 
-def cut_page(items: list[T], page_size: int, page_number: int) -> tuple[list[T], bool]:
+def cut_page(items: list[T], top_k: int) -> tuple[list[T], bool]:
     """Return a slice of `items` representing the specified page and a boolean
     indicating whether there is a next page or not"""
-    start = page_size * page_number
-    end = start + page_size
-    next_page = len(items) > end
-    return items[start:end], next_page
+    next_page = len(items) > top_k
+    return items[:top_k], next_page

nucliadb/search/search/find.py

@@ -122,8 +122,7 @@ async def _index_node_retrieval(
             relation_subgraph_query=pb_query.relations.subgraph,
             min_score_bm25=pb_query.min_score_bm25,
             min_score_semantic=pb_query.min_score_semantic,
-            page_size=item.top_k,
-            page_number=0,
+            top_k=item.top_k,
             show=item.show,
             extracted=item.extracted,
             field_type_filter=item.field_type_filter,
@@ -214,7 +213,7 @@ async def _external_index_retrieval(
             kbid=kbid,
             query=search_request.body,
         ),
-        top_k=query_parser.page_size,
+        top_k=query_parser.top_k,
     )
     find_resources = compose_find_resources(text_blocks, resources)
 
@@ -273,8 +272,7 @@ async def query_parser_from_find_request(
         keyword_filters=item.keyword_filters,
         faceted=None,
         sort=None,
-        page_number=0,
-        page_size=item.top_k,
+        top_k=item.top_k,
         min_score=item.min_score,
         range_creation_start=item.range_creation_start,
         range_creation_end=item.range_creation_end,

nucliadb/search/search/find_merge.py

@@ -75,8 +75,7 @@ async def build_find_response(
     kbid: str,
     query: str,
     relation_subgraph_query: EntitiesSubgraphRequest,
-    page_size: int,
-    page_number: int,
+    top_k: int,
     min_score_bm25: float,
     min_score_semantic: float,
     rank_fusion_algorithm: RankFusionAlgorithm,
@@ -106,9 +105,9 @@ async def build_find_response(
     # enforced/validated by the query parsing.
     if reranker.needs_extra_results:
         assert reranker.window is not None, "Reranker definition must enforce this condition"
-        text_blocks_page, next_page = cut_page(merged_text_blocks, reranker.window, 0)
+        text_blocks_page, next_page = cut_page(merged_text_blocks, reranker.window)
     else:
-        text_blocks_page, next_page = cut_page(merged_text_blocks, page_size, page_number)
+        text_blocks_page, next_page = cut_page(merged_text_blocks, top_k)
 
     # hydrate and rerank
     resource_hydration_options = ResourceHydrationOptions(
@@ -126,7 +125,7 @@ async def build_find_response(
         text_block_hydration_options=text_block_hydration_options,
         reranker=reranker,
         reranking_options=reranking_options,
-        top_k=page_size,
+        top_k=top_k,
     )
 
     # build relations graph
@@ -144,8 +143,8 @@ async def build_find_response(
         best_matches=best_matches,
         relations=relations,
         total=total_paragraphs,
-        page_number=page_number,
-        page_size=page_size,
+        page_number=0,  # Bw/c with pagination
+        page_size=top_k,
         next_page=next_page,
         min_score=MinScore(bm25=_round(min_score_bm25), semantic=_round(min_score_semantic)),
     )

nucliadb/search/search/merge.py

@@ -24,6 +24,7 @@ from typing import Any, Optional, Set, Union
 
 from nucliadb.common.ids import FieldId, ParagraphId
 from nucliadb.search.search import cache
+from nucliadb.search.search.cut import cut_page
 from nucliadb.search.search.fetch import (
     fetch_resources,
     get_labels_paragraph,
@@ -118,8 +119,7 @@ async def get_sort_value(
 async def merge_documents_results(
     document_responses: list[DocumentSearchResponse],
     resources: list[str],
-    count: int,
-    page: int,
+    top_k: int,
     kbid: str,
     sort: SortOptions,
     min_score: float,
@@ -148,15 +148,9 @@ async def merge_documents_results(
                 raw_resource_list.append((result, sort_value))
         total += document_response.total
 
-    skip = page * count
-    end = skip + count
-    length = len(raw_resource_list)
-
-    if length > end:
-        next_page = True
-
-    # We need to cut first and then sort, otherwise pagination will be wrong if the order is DESC
-    raw_resource_list = raw_resource_list[min(skip, length) : min(end, length)]
+    # We need to cut first and then sort, otherwise the page will be wrong if the order is DESC
+    raw_resource_list, has_more = cut_page(raw_resource_list, top_k)
+    next_page = next_page or has_more
     raw_resource_list.sort(key=lambda x: x[1], reverse=(sort.order == SortOrder.DESC))
 
     result_resource_list: list[ResourceResult] = []
@@ -181,8 +175,8 @@ async def merge_documents_results(
         results=result_resource_list,
         query=query,
         total=total,
-        page_number=page,
-        page_size=count,
+        page_number=0,  # Bw/c with pagination
+        page_size=top_k,
         next_page=next_page,
         min_score=min_score,
     )
@@ -258,8 +252,7 @@ async def merge_vectors_results(
     vector_responses: list[VectorSearchResponse],
     resources: list[str],
     kbid: str,
-    count: int,
-    page: int,
+    top_k: int,
     min_score: Optional[float] = None,
 ):
     facets: dict[str, Any] = {}
@@ -276,12 +269,10 @@ async def merge_vectors_results(
     if len(vector_responses) > 1:
         raw_vectors_list.sort(key=lambda x: x.score, reverse=True)
 
-    skip = page * count
-    end_element = skip + count
-    length = len(raw_vectors_list)
+    raw_vectors_list, _ = cut_page(raw_vectors_list, top_k)
 
     result_sentence_list: list[Sentence] = []
-    for result in raw_vectors_list[min(skip, length) : min(end_element, length)]:
+    for result in raw_vectors_list:
         id_count = result.doc_id.id.count("/")
         if id_count == 4:
             rid, field_type, field, index, position = result.doc_id.id.split("/")
@@ -329,8 +320,8 @@ async def merge_vectors_results(
     return Sentences(
         results=result_sentence_list,
         facets=facets,
-        page_number=page,
-        page_size=count,
+        page_number=0,  # Bw/c with pagination
+        page_size=top_k,
         min_score=round(min_score or 0, ndigits=3),
     )
 
@@ -339,8 +330,7 @@ async def merge_paragraph_results(
     paragraph_responses: list[ParagraphSearchResponse],
     resources: list[str],
     kbid: str,
-    count: int,
-    page: int,
+    top_k: int,
     highlight: bool,
     sort: SortOptions,
     min_score: float,
@@ -374,15 +364,11 @@ async def merge_paragraph_results(
 
     raw_paragraph_list.sort(key=lambda x: x[1], reverse=(sort.order == SortOrder.DESC))
 
-    skip = page * count
-    end = skip + count
-    length = len(raw_paragraph_list)
-
-    if length > end:
-        next_page = True
+    raw_paragraph_list, has_more = cut_page(raw_paragraph_list, top_k)
+    next_page = next_page or has_more
 
     result_paragraph_list: list[Paragraph] = []
-    for result, _ in raw_paragraph_list[min(skip, length) : min(end, length)]:
+    for result, _ in raw_paragraph_list:
         _, field_type, field = result.field.split("/")
         text = await get_paragraph_text(
             kbid=kbid,
@@ -435,8 +421,8 @@ async def merge_paragraph_results(
         facets=facets,
         query=query,
         total=total,
-        page_number=page,
-        page_size=count,
+        page_number=0,  # Bw/c with pagination
+        page_size=top_k,
         next_page=next_page,
         min_score=min_score,
     )
@@ -494,8 +480,7 @@ def _merge_relations_results(
 @merge_observer.wrap({"type": "merge"})
 async def merge_results(
     search_responses: list[SearchResponse],
-    count: int,
-    page: int,
+    top_k: int,
     kbid: str,
     show: list[ResourceProperties],
     field_type_filter: list[FieldTypeName],
@@ -520,22 +505,21 @@ async def merge_results(
 
     resources: list[str] = list()
     api_results.fulltext = await merge_documents_results(
-        documents, resources, count, page, kbid, sort, min_score=min_score.bm25
+        documents, resources, top_k, kbid, sort, min_score=min_score.bm25
     )
 
     api_results.paragraphs = await merge_paragraph_results(
         paragraphs,
         resources,
         kbid,
-        count,
-        page,
+        top_k,
         highlight,
         sort,
         min_score=min_score.bm25,
     )
 
     api_results.sentences = await merge_vectors_results(
-        vectors, resources, kbid, count, page, min_score=min_score.semantic
+        vectors, resources, kbid, top_k, min_score=min_score.semantic
     )
 
     api_results.relations = await merge_relations_results(relations, requested_relations)
@@ -546,8 +530,7 @@ async def merge_results(
 
 async def merge_paragraphs_results(
     responses: list[SearchResponse],
-    count: int,
-    page: int,
+    top_k: int,
     kbid: str,
     highlight_split: bool,
     min_score: float,
@@ -563,8 +546,7 @@ async def merge_paragraphs_results(
         paragraphs,
         resources,
         kbid,
-        count,
-        page,
+        top_k,
         highlight=highlight_split,
         sort=SortOptions(
             field=SortField.SCORE,

nucliadb/search/search/pgcatalog.py

@@ -26,6 +26,7 @@ from psycopg.rows import dict_row
 
 from nucliadb.common.maindb.pg import PGDriver
 from nucliadb.common.maindb.utils import get_driver
+from nucliadb.search.search.query_parser.models import CatalogQuery
 from nucliadb_models.labels import translate_system_to_alias_label
 from nucliadb_models.metadata import ResourceProcessingStatus
 from nucliadb_models.search import (
@@ -37,7 +38,6 @@ from nucliadb_models.search import (
 from nucliadb_telemetry import metrics
 
 from .filters import translate_label
-from .query import QueryParser
 
 observer = metrics.Observer("pg_catalog_search", labels={"op": ""})
 logger = logging.getLogger(__name__)
@@ -79,60 +79,60 @@ def _convert_filter(filter, filter_params):
         raise ValueError(f"Invalid operator {op}")
 
 
-def _prepare_query(query_parser: QueryParser):
+def _prepare_query(catalog_query: CatalogQuery):
     filter_sql = ["kbid = %(kbid)s"]
-    filter_params: dict[str, Any] = {"kbid": query_parser.kbid}
+    filter_params: dict[str, Any] = {"kbid": catalog_query.kbid}
 
-    if query_parser.query:
+    if catalog_query.query:
         # This is doing tokenization inside the SQL server (to keep the index updated). We could move it to
         # the python code at update/query time if it ever becomes a problem but for now, a single regex
         # executed per query is not a problem.
         filter_sql.append(
             "regexp_split_to_array(lower(title), '\\W') @> regexp_split_to_array(lower(%(query)s), '\\W')"
         )
-        filter_params["query"] = query_parser.query
+        filter_params["query"] = catalog_query.query
 
-    if query_parser.range_creation_start:
+    if catalog_query.filters.creation.after:
         filter_sql.append("created_at > %(created_at_start)s")
-        filter_params["created_at_start"] = query_parser.range_creation_start
+        filter_params["created_at_start"] = catalog_query.filters.creation.after
 
-    if query_parser.range_creation_end:
+    if catalog_query.filters.creation.before:
         filter_sql.append("created_at < %(created_at_end)s")
-        filter_params["created_at_end"] = query_parser.range_creation_end
+        filter_params["created_at_end"] = catalog_query.filters.creation.before
 
-    if query_parser.range_modification_start:
+    if catalog_query.filters.modification.after:
         filter_sql.append("modified_at > %(modified_at_start)s")
-        filter_params["modified_at_start"] = query_parser.range_modification_start
+        filter_params["modified_at_start"] = catalog_query.filters.modification.after
 
-    if query_parser.range_modification_end:
+    if catalog_query.filters.modification.before:
         filter_sql.append("modified_at < %(modified_at_end)s")
-        filter_params["modified_at_end"] = query_parser.range_modification_end
+        filter_params["modified_at_end"] = catalog_query.filters.modification.before
 
-    if query_parser.label_filters:
-        filter_sql.append(_convert_filter(query_parser.label_filters, filter_params))
+    if catalog_query.filters.labels:
+        filter_sql.append(_convert_filter(catalog_query.filters.labels, filter_params))
 
     order_sql = ""
-    if query_parser.sort:
-        if query_parser.sort.field == SortField.CREATED:
+    if catalog_query.sort:
+        if catalog_query.sort.field == SortField.CREATED:
             order_field = "created_at"
-        elif query_parser.sort.field == SortField.MODIFIED:
+        elif catalog_query.sort.field == SortField.MODIFIED:
             order_field = "modified_at"
-        elif query_parser.sort.field == SortField.TITLE:
+        elif catalog_query.sort.field == SortField.TITLE:
             order_field = "title"
         else:
             # Deprecated order by score, use created_at instead
             order_field = "created_at"
 
-        if query_parser.sort.order == SortOrder.ASC:
+        if catalog_query.sort.order == SortOrder.ASC:
             order_dir = "ASC"
         else:
             order_dir = "DESC"
 
         order_sql = f" ORDER BY {order_field} {order_dir}"
 
-    if query_parser.with_status:
+    if catalog_query.filters.with_status:
         filter_sql.append("labels && %(status)s")
-        if query_parser.with_status == ResourceProcessingStatus.PROCESSED:
+        if catalog_query.filters.with_status == ResourceProcessingStatus.PROCESSED:
             filter_params["status"] = ["/n/s/PROCESSED", "/n/s/ERROR"]
         else:
             filter_params["status"] = ["/n/s/PENDING"]
@@ -148,18 +148,18 @@ def _pg_driver() -> PGDriver:
 
 
 @observer.wrap({"op": "search"})
-async def pgcatalog_search(query_parser: QueryParser) -> Resources:
+async def pgcatalog_search(catalog_query: CatalogQuery) -> Resources:
     # Prepare SQL query
-    query, query_params = _prepare_query(query_parser)
+    query, query_params = _prepare_query(catalog_query)
 
     async with _pg_driver()._get_connection() as conn, conn.cursor(row_factory=dict_row) as cur:
         facets = {}
 
         # Faceted search
-        if query_parser.faceted:
+        if catalog_query.faceted:
             with observer({"op": "facets"}):
                 tmp_facets: dict[str, dict[str, int]] = {
-                    translate_label(f): defaultdict(int) for f in query_parser.faceted
+                    translate_label(f): defaultdict(int) for f in catalog_query.faceted
                 }
                 facet_filters = " OR ".join(f"label LIKE '{f}/%%'" for f in tmp_facets.keys())
                 for facet in tmp_facets.keys():
@@ -167,7 +167,7 @@ async def pgcatalog_search(query_parser: QueryParser) -> Resources:
                         facet.startswith("/n/s") or facet.startswith("/n/i") or facet.startswith("/l")
                     ):
                         logger.warn(
-                            f"Unexpected facet used at catalog: {facet}, kbid={query_parser.kbid}"
+                            f"Unexpected facet used at catalog: {facet}, kbid={catalog_query.kbid}"
                         )
 
                 await cur.execute(
@@ -201,12 +201,12 @@ async def pgcatalog_search(query_parser: QueryParser) -> Resources:
 
         # Query
         with observer({"op": "query"}):
-            offset = query_parser.page_size * query_parser.page_number
+            offset = catalog_query.page_size * catalog_query.page_number
             await cur.execute(
                 f"{query} LIMIT %(page_size)s OFFSET %(offset)s",
                 {
                     **query_params,
-                    "page_size": query_parser.page_size,
+                    "page_size": catalog_query.page_size,
                     "offset": offset,
                 },
             )
@@ -224,10 +224,10 @@ async def pgcatalog_search(query_parser: QueryParser) -> Resources:
             )
             for r in data
         ],
-        query=query_parser.query,
+        query=catalog_query.query,
         total=total,
-        page_number=query_parser.page_number,
-        page_size=query_parser.page_size,
+        page_number=catalog_query.page_number,
+        page_size=catalog_query.page_size,
         next_page=(offset + len(data) < total),
         min_score=0,
     )

nucliadb/search/search/query.py

@@ -74,7 +74,6 @@ INDEX_SORTABLE_FIELDS = [
     SortField.MODIFIED,
 ]
 
-MAX_VECTOR_RESULTS_ALLOWED = 2000
 DEFAULT_GENERIC_SEMANTIC_THRESHOLD = 0.7
 
 
@@ -105,8 +104,7 @@ class QueryParser:
         query: str,
         label_filters: Union[list[str], list[Filter]],
         keyword_filters: Union[list[str], list[Filter]],
-        page_number: int,
-        page_size: int,
+        top_k: int,
         min_score: MinScore,
         faceted: Optional[list[str]] = None,
         sort: Optional[SortOptions] = None,
@@ -145,8 +143,7 @@ class QueryParser:
         self.flat_label_filters: list[str] = []
         self.keyword_filters: dict[str, Any] = convert_to_node_filters(keyword_filters)
         self.faceted = faceted or []
-        self.page_number = page_number
-        self.page_size = page_size
+        self.top_k = top_k
         self.min_score = min_score
         self.sort = sort
         self.range_creation_start = range_creation_start
@@ -389,19 +386,13 @@ class QueryParser:
             # have consistent results, we must limit them
             request.result_per_page = self.sort.limit
         else:
-            request.result_per_page = self.page_number * self.page_size + self.page_size
+            request.result_per_page = self.top_k
 
         sort_field = SortFieldMap[self.sort.field] if self.sort else None
         if sort_field is not None:
             request.order.sort_by = sort_field
             request.order.type = SortOrderMap[self.sort.order]  # type: ignore
 
-        if self.has_vector_search and request.result_per_page > MAX_VECTOR_RESULTS_ALLOWED:
-            raise InvalidQueryError(
-                "page_size",
-                f"Pagination of semantic results limit reached: {MAX_VECTOR_RESULTS_ALLOWED}. If you want to paginate through all results, please disable the vector search feature.",  # noqa: E501
-            )
-
     async def parse_min_score(self, request: nodereader_pb2.SearchRequest, incomplete: bool) -> None:
         semantic_min_score = DEFAULT_GENERIC_SEMANTIC_THRESHOLD
         if self.min_score.semantic is not None:
@@ -635,8 +626,7 @@ async def paragraph_query_to_pb(
     fields: list[str],
     filters: list[str],
     faceted: list[str],
-    page_number: int,
-    page_size: int,
+    top_k: int,
     range_creation_start: Optional[datetime] = None,
     range_creation_end: Optional[datetime] = None,
     range_modification_start: Optional[datetime] = None,
@@ -650,7 +640,7 @@ async def paragraph_query_to_pb(
 
     # We need to ask for all and cut later
     request.page_number = 0
-    request.result_per_page = page_number * page_size + page_size
+    request.result_per_page = top_k
 
     request.body = query
 

nucliadb/search/search/query_parser/models.py

@@ -19,6 +19,8 @@
 #
 
 from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Optional
 
 from pydantic import (
     BaseModel,
@@ -27,6 +29,16 @@ from pydantic import (
 
 from nucliadb_models import search as search_models
 
+### Retrieval
+
+# filters
+
+
+class DateTimeFilter(BaseModel):
+    after: Optional[datetime] = None  # aka, start
+    before: Optional[datetime] = None  # aka, end
+
+
 # rank fusion
 
 
@@ -65,3 +77,25 @@ class UnitRetrieval:
     top_k: int
     rank_fusion: RankFusion
     reranker: Reranker
+
+
+### Catalog
+
+
+class CatalogFilters(BaseModel):
+    labels: dict[str, Any] = Field(
+        default_factory=dict, description="Labels filter expression, like, `{and: {not: ...}, ...}`"
+    )
+    creation: DateTimeFilter
+    modification: DateTimeFilter
+    with_status: Optional[search_models.ResourceProcessingStatus] = None
+
+
+class CatalogQuery(BaseModel):
+    kbid: str
+    query: str
+    filters: CatalogFilters
+    sort: search_models.SortOptions
+    faceted: list[str]
+    page_size: int
+    page_number: int

nucliadb/search/search/query_parser/parser.py

@@ -18,11 +18,19 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 
+from typing import Any
 
 from pydantic import ValidationError
 
+from nucliadb.search.search.filters import (
+    convert_to_node_filters,
+    translate_label_filters,
+)
 from nucliadb.search.search.query_parser.exceptions import ParserError
 from nucliadb.search.search.query_parser.models import (
+    CatalogFilters,
+    CatalogQuery,
+    DateTimeFilter,
     MultiMatchBoosterReranker,
     NoopReranker,
     PredictReranker,
@@ -32,7 +40,14 @@ from nucliadb.search.search.query_parser.models import (
     UnitRetrieval,
 )
 from nucliadb_models import search as search_models
-from nucliadb_models.search import FindRequest
+from nucliadb_models.labels import LABEL_HIDDEN
+from nucliadb_models.search import (
+    Filter,
+    FindRequest,
+    SortField,
+    SortOptions,
+    SortOrder,
+)
 
 
 def parse_find(item: FindRequest) -> UnitRetrieval:
@@ -69,9 +84,6 @@ class _FindParser:
         )
 
     def _parse_top_k(self) -> int:
-        # while pagination is still there, FindRequest has a validator that converts
-        # top_k to page_number and page_size. To get top_k, we can compute it from
-        # those
         assert self.item.top_k is not None, "top_k must have an int value"
         top_k = self.item.top_k
         return top_k
@@ -129,3 +141,43 @@ class _FindParser:
             raise ParserError(f"Unknown reranker {self.item.reranker}")
 
         return reranking
+
+
+def parse_catalog(kbid: str, item: search_models.CatalogRequest) -> CatalogQuery:
+    if item.hidden:
+        hidden_filter = Filter(all=[LABEL_HIDDEN])
+    else:
+        hidden_filter = Filter(none=[LABEL_HIDDEN])
+    label_filters: dict[str, Any] = convert_to_node_filters(item.filters + [hidden_filter])  # type: ignore
+    if len(label_filters) > 0:
+        label_filters = translate_label_filters(label_filters)
+
+    sort = item.sort
+    if sort is None:
+        # By default we sort by creation date (most recent first)
+        sort = SortOptions(
+            field=SortField.CREATED,
+            order=SortOrder.DESC,
+            limit=None,
+        )
+
+    return CatalogQuery(
+        kbid=kbid,
+        query=item.query,
+        filters=CatalogFilters(
+            labels=label_filters,
+            creation=DateTimeFilter(
+                after=item.range_creation_start,
+                before=item.range_creation_end,
+            ),
+            modification=DateTimeFilter(
+                after=item.range_modification_start,
+                before=item.range_modification_end,
+            ),
+            with_status=item.with_status,
+        ),
+        sort=sort,
+        faceted=item.faceted,
+        page_number=item.page_number,
+        page_size=item.page_size,
+    )

{nucliadb-6.1.0.post2594.dist-info → nucliadb-6.1.0.post2610.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nucliadb
-Version: 6.1.0.post2594
+Version: 6.1.0.post2610
 Home-page: https://docs.nuclia.dev/docs/management/nucliadb/intro
 Author: NucliaDB Community
 Author-email: nucliadb@nuclia.com
@@ -22,10 +22,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.9, <4
 Description-Content-Type: text/markdown
-Requires-Dist: nucliadb-telemetry[all]>=6.1.0.post2594
-Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.1.0.post2594
-Requires-Dist: nucliadb-protos>=6.1.0.post2594
-Requires-Dist: nucliadb-models>=6.1.0.post2594
+Requires-Dist: nucliadb-telemetry[all]>=6.1.0.post2610
+Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.1.0.post2610
+Requires-Dist: nucliadb-protos>=6.1.0.post2610
+Requires-Dist: nucliadb-models>=6.1.0.post2610
 Requires-Dist: nucliadb-admin-assets>=1.0.0.post1224
 Requires-Dist: nucliadb-node-binding>=2.26.0
 Requires-Dist: uvicorn

{nucliadb-6.1.0.post2594.dist-info → nucliadb-6.1.0.post2610.dist-info}/RECORD

@@ -190,52 +190,53 @@ nucliadb/search/run.py,sha256=aFb-CXRi_C8YMpP_ivNj8KW1BYhADj88y8K9Lr_nUPI,1402
 nucliadb/search/settings.py,sha256=vem3EcyYlTPSim0kEK-xe-erF4BZg0CT_LAb8ZRQAE8,1684
 nucliadb/search/utilities.py,sha256=9SsRDw0rJVXVoLBfF7rBb6q080h-thZc7u8uRcTiBeY,1037
 nucliadb/search/api/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
-nucliadb/search/api/v1/__init__.py,sha256=Xep7u4Q7ygHvTGRn2CzRwJRVX1jtoSxUg8usQcVbC2s,1219
+nucliadb/search/api/v1/__init__.py,sha256=NSbOVF6toiHX9WMpGgqpFrjJKT50EcHzOILp-2iHk5I,1249
 nucliadb/search/api/v1/ask.py,sha256=Od2U_gaOZK6dJZ1eDGQQJ3xUVnbBih58VPYVAsQErOw,3902
+nucliadb/search/api/v1/catalog.py,sha256=ubYPS1wmPHzOgH9LR0qJmmV-9ELZPtHRSs5TYJ1pA9A,7117
 nucliadb/search/api/v1/feedback.py,sha256=yrOZeElw6XLu6j_6m3QGHKjEMwZPWa9vtdCud4dNilU,2547
 nucliadb/search/api/v1/find.py,sha256=DsnWkySu_cFajDWJIxN8DYvLL_Rm2yiCjHD8TsqPfRk,9304
 nucliadb/search/api/v1/knowledgebox.py,sha256=PKT1V3vZUnBkGfkxnFGjWPuHwQarVxREDY7lAT_9k1w,8764
 nucliadb/search/api/v1/predict_proxy.py,sha256=QrGzo0hKjtmyGZ6pjlJHYAh4hxwVUIOTcVcerRCw7eE,3047
 nucliadb/search/api/v1/router.py,sha256=mtT07rBZcVfpa49doaw9b1tj3sdi3qLH0gn9Io6NYM0,988
-nucliadb/search/api/v1/search.py,sha256=9QO2-AI1b2WJX8gmURB02cih1ONWjHe0-qnL1SXbF_E,19864
+nucliadb/search/api/v1/search.py,sha256=_5J8lIzLjfFW3j-XeaebaJqcO1vxm0W2oaX4unFJ5e8,13577
 nucliadb/search/api/v1/suggest.py,sha256=SXxRVKT5hDSHNKlBYo8XozHHq9bGyvJOlo286lEruLE,5979
 nucliadb/search/api/v1/summarize.py,sha256=VAHJvE6V3xUgEBfqNKhgoxmDqCvh30RnrEIBVhMcNLU,2499
 nucliadb/search/api/v1/utils.py,sha256=5Ve-frn7LAE2jqAgB85F8RSeqxDlyA08--gS-AdOLS4,1434
 nucliadb/search/api/v1/resource/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/search/api/v1/resource/ask.py,sha256=XMEP9_Uwy37yaXLcIYKMXGiZYNASD8RTByzQGjd9LPQ,3847
-nucliadb/search/api/v1/resource/search.py,sha256=jgYJnSSult2ah_Jfd78vbGT5URyZPDsX1Gbdj-sQgCE,4851
+nucliadb/search/api/v1/resource/search.py,sha256=X0rQU14r_s4_CPpoE2sc84AJPX68gvCftcP4bosWHhA,4812
 nucliadb/search/requesters/__init__.py,sha256=itSI7dtTwFP55YMX4iK7JzdMHS5CQVUiB1XzQu4UBh8,833
 nucliadb/search/requesters/utils.py,sha256=7ovWSGzhLpZGTMi9x9nMOi7QNCgt2qah-7Kam-cIvUg,8468
 nucliadb/search/search/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/search/search/cache.py,sha256=n9vkN6Y6Xnr2RBJyoH0WzjzGTJOMfKekU9tfPTWWCPc,6810
-nucliadb/search/search/cut.py,sha256=1lmQpc8p5G8okHcPZ5GKH1F60Qr72HpKGoZI7H15Wzs,1240
+nucliadb/search/search/cut.py,sha256=ytY0_GY7ocNjfxTb4aosxEp4ZfhQNDP--JkhEMGD298,1153
 nucliadb/search/search/exceptions.py,sha256=mbToQ-ghrv8ukLEv8S_-EZrgweWaIZZ5SIpoeuGDk6s,1154
 nucliadb/search/search/fetch.py,sha256=XJHIFnZmXM_8Kb37lb4lg1GYG7cZ1plT-qAIb_QziX4,6184
 nucliadb/search/search/filters.py,sha256=1MkHlJjAQqoRCj7e5cEzK2HvBxGLE17I_omsjiklbtw,6476
-nucliadb/search/search/find.py,sha256=KvRuPwvaZCxgxpHQtetPt9gy5DS9cszLu2oKyiDc3Cg,9891
-nucliadb/search/search/find_merge.py,sha256=oM71fbLamlVmwTuSQm9Z2lRNU63Ak7iHL_6mxwvVwB4,17218
+nucliadb/search/search/find.py,sha256=EPtnb3jJcj6_4Brzk0mRkd9meY26OVGfW5dj-RKk2yU,9829
+nucliadb/search/search/find_merge.py,sha256=_R_YpHAZv5BHh3XABQ8MRd1Ci0seclGYf26yJHJ7H0I,17178
 nucliadb/search/search/hydrator.py,sha256=7Zi44uf2m9b2X_b1aOV2lrWu1Vmbo9lXYgPVUGK0RGI,6728
-nucliadb/search/search/merge.py,sha256=SfAzDKUEAQ2JUf6K6MEhGZZCJXwdsN9vusRIhdg7ajI,20325
+nucliadb/search/search/merge.py,sha256=TATahN22AX23gJ-2hxGiIZLjj6H1AtnIeADN6jC11HY,20079
 nucliadb/search/search/metrics.py,sha256=81X-tahGW4n2CLvUzCPdNxNClmZqUWZjcVOGCUHoiUM,2872
 nucliadb/search/search/paragraphs.py,sha256=pNAEiYqJGGUVcEf7xf-PFMVqz0PX4Qb-WNG-_zPGN2o,7799
-nucliadb/search/search/pgcatalog.py,sha256=cHiUZzrEnCdiM_0F5HCid8xJDDzFDbK-3cDSvGmCT4s,8738
+nucliadb/search/search/pgcatalog.py,sha256=IaNK4dAxdXs38PoIkTdgqMDuZDjeiOtcXn3LeaT-OMw,8855
 nucliadb/search/search/predict_proxy.py,sha256=xBlh6kjuQpWRq7KsBx4pEl2PtnwljjQIiYMaTWpcCSA,3015
-nucliadb/search/search/query.py,sha256=O3ry3PPGjGLtH8AXssyyzDxStu57W5PK-bvUfCOMaqY,38309
+nucliadb/search/search/query.py,sha256=1g_kek5mbxXPrFbs2ptTrFfr-WwZjsjMUHOw9Le2vZ4,37732
 nucliadb/search/search/rank_fusion.py,sha256=tRGo_KlsFsVx1CQEy1iqQ6f0T1Dq1kf0axDXHuuzvvM,6946
 nucliadb/search/search/rerankers.py,sha256=0kAHES9X_FKkP7KSN9NRETFmRPKzwrFAo_54MbyvM7Q,9051
 nucliadb/search/search/shards.py,sha256=mM2aCHWhl_gwkCENXDShPukS-_qnB5tFS3UAJuzM9qA,2182
 nucliadb/search/search/summarize.py,sha256=ksmYPubEQvAQgfPdZHfzB_rR19B2ci4IYZ6jLdHxZo8,4996
 nucliadb/search/search/utils.py,sha256=iF2tbBA56gRMJH1TlE2hMrqeXqjoeOPt4KgRdp2m9Ek,3313
 nucliadb/search/search/chat/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
-nucliadb/search/search/chat/ask.py,sha256=tUPsJpRCj7Sw7wHTpp5Mq1G9UDrYliCkYiIFdZ7qv_Y,33834
+nucliadb/search/search/chat/ask.py,sha256=7yUPEMluZ553O4FdcghyQI3Hw042P3QL06T0AwDctJI,33799
 nucliadb/search/search/chat/exceptions.py,sha256=Siy4GXW2L7oPhIR86H3WHBhE9lkV4A4YaAszuGGUf54,1356
 nucliadb/search/search/chat/images.py,sha256=PA8VWxT5_HUGfW1ULhKTK46UBsVyINtWWqEM1ulzX1E,3095
 nucliadb/search/search/chat/prompt.py,sha256=TIzjI_882hJ--KLKCY8rJomtJ_CMJ-MHYtHqivgG8Lk,46819
 nucliadb/search/search/chat/query.py,sha256=gKtlj2ms81m417Id29-DtHFxE3M4TtJvYNB03gAgpYo,14402
 nucliadb/search/search/query_parser/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/search/search/query_parser/exceptions.py,sha256=tuzl7ZyvVsRz6u0_3zMe60vx39nd3pi641prs-5nC0E,872
-nucliadb/search/search/query_parser/models.py,sha256=BNHwpItSLCZIDclcDpwDiu-BBQfmEn6xkxCErrMPgVU,1590
-nucliadb/search/search/query_parser/parser.py,sha256=DGVtph_ZlRiLQJJdoH07qrUvur6LQpiozwtgbO-SNqs,4890
+nucliadb/search/search/query_parser/models.py,sha256=-VlCDXUCgOroAZw1Leqhj2VMgRv_CD2w40PXXOBLaUM,2332
+nucliadb/search/search/query_parser/parser.py,sha256=ElKx9JboJCSqBiFiEAVVH-JM0_7ykc_cdY4TbKfAxUg,6296
 nucliadb/standalone/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/standalone/api_router.py,sha256=zR03TQ-Pd2kXx1jeV83Puw19112Z8Jhln7p1cAn69kg,6699
 nucliadb/standalone/app.py,sha256=mAApNK_iVsQgJyd-mtwCeZq5csSimwnXmlQGH9a70pE,5586
@@ -331,9 +332,9 @@ nucliadb/writer/tus/local.py,sha256=7jYa_w9b-N90jWgN2sQKkNcomqn6JMVBOVeDOVYJHto,
 nucliadb/writer/tus/s3.py,sha256=vF0NkFTXiXhXq3bCVXXVV-ED38ECVoUeeYViP8uMqcU,8357
 nucliadb/writer/tus/storage.py,sha256=ToqwjoYnjI4oIcwzkhha_MPxi-k4Jk3Lt55zRwaC1SM,2903
 nucliadb/writer/tus/utils.py,sha256=MSdVbRsRSZVdkaum69_0wku7X3p5wlZf4nr6E0GMKbw,2556
-nucliadb-6.1.0.post2594.dist-info/METADATA,sha256=yth5qp_Am2HEo9HU5DwRFfNx0wzYxAMekpT3it9DgAY,4390
-nucliadb-6.1.0.post2594.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-nucliadb-6.1.0.post2594.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
-nucliadb-6.1.0.post2594.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
-nucliadb-6.1.0.post2594.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-nucliadb-6.1.0.post2594.dist-info/RECORD,,
+nucliadb-6.1.0.post2610.dist-info/METADATA,sha256=hq7ECRkXdli7ZqMNQKUI1ZjJyi0ww7yCXEC7asizcCk,4390
+nucliadb-6.1.0.post2610.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+nucliadb-6.1.0.post2610.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
+nucliadb-6.1.0.post2610.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
+nucliadb-6.1.0.post2610.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+nucliadb-6.1.0.post2610.dist-info/RECORD,,