nucliadb 6.3.7.post4066__py3-none-any.whl → 6.3.7.post4068__py3-none-any.whl

nucliadb/search/search/query_parser/parsers/search.py

@@ -0,0 +1,249 @@
+# 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 typing import Optional
+
+from nucliadb.search.search.metrics import query_parser_observer
+from nucliadb.search.search.query import expand_entities
+from nucliadb.search.search.query_parser.exceptions import InvalidQueryError
+from nucliadb.search.search.query_parser.fetcher import Fetcher
+from nucliadb.search.search.query_parser.filter_expression import parse_expression
+from nucliadb.search.search.query_parser.models import (
+    Filters,
+    NoopReranker,
+    ParsedQuery,
+    Query,
+    RankFusion,
+    RelationQuery,
+    UnitRetrieval,
+    _TextQuery,
+)
+from nucliadb.search.search.query_parser.old_filters import OldFilterParams, parse_old_filters
+from nucliadb.search.search.utils import filter_hidden_resources
+from nucliadb_models import search as search_models
+from nucliadb_models.filters import FilterExpression
+from nucliadb_models.search import (
+    SearchRequest,
+    SortField,
+    SortOptions,
+    SortOrder,
+)
+from nucliadb_protos import nodereader_pb2, utils_pb2
+
+from .common import parse_keyword_query, parse_semantic_query, parse_top_k, validate_base_request
+
+INDEX_SORTABLE_FIELDS = [
+    SortField.CREATED,
+    SortField.MODIFIED,
+]
+
+
+@query_parser_observer.wrap({"type": "parse_search"})
+async def parse_search(
+    kbid: str, item: SearchRequest, *, fetcher: Optional[Fetcher] = None
+) -> ParsedQuery:
+    fetcher = fetcher or fetcher_for_search(kbid, item)
+    parser = _SearchParser(kbid, item, fetcher)
+    retrieval = await parser.parse()
+    return ParsedQuery(fetcher=fetcher, retrieval=retrieval, generation=None)
+
+
+def fetcher_for_search(kbid: str, item: SearchRequest) -> Fetcher:
+    return Fetcher(
+        kbid=kbid,
+        query=item.query,
+        user_vector=item.vector,
+        vectorset=item.vectorset,
+        rephrase=item.rephrase,
+        rephrase_prompt=item.rephrase_prompt,
+        generative_model=None,
+    )
+
+
+class _SearchParser:
+    def __init__(self, kbid: str, item: SearchRequest, fetcher: Fetcher):
+        self.kbid = kbid
+        self.item = item
+        self.fetcher = fetcher
+
+        # cached data while parsing
+        self._query: Optional[Query] = None
+        self._top_k: Optional[int] = None
+
+    async def parse(self) -> UnitRetrieval:
+        validate_base_request(self.item)
+
+        self._top_k = parse_top_k(self.item)
+
+        # parse search types (features)
+
+        self._query = Query()
+
+        if search_models.SearchOptions.KEYWORD in self.item.features:
+            keyword = await self._parse_text_query()
+            self._query.keyword = keyword
+
+        if search_models.SearchOptions.FULLTEXT in self.item.features:
+            # copy from keyword, as everything is the same and we can't search
+            # anything different right now
+            keyword = self._query.keyword or (await self._parse_text_query())
+            self._query.fulltext = keyword
+
+        if search_models.SearchOptions.SEMANTIC in self.item.features:
+            self._query.semantic = await parse_semantic_query(self.item, fetcher=self.fetcher)
+
+        if search_models.SearchOptions.RELATIONS in self.item.features:
+            self._query.relation = await self._parse_relation_query()
+
+        filters = await self._parse_filters()
+
+        return UnitRetrieval(
+            query=self._query,
+            top_k=self._top_k,
+            filters=filters,
+            # TODO: this should be in a post retrieval step
+            rank_fusion=RankFusion(window=self._top_k),
+            reranker=NoopReranker(),
+        )
+
+    async def _parse_text_query(self) -> _TextQuery:
+        assert self._top_k is not None, "top_k must be parsed before text query"
+
+        keyword = await parse_keyword_query(self.item, fetcher=self.fetcher)
+        sort, order_by, limit = self._parse_sorting()
+        keyword.sort = sort
+        keyword.order_by = order_by
+        if limit is not None:
+            # sort limit can extend top_k
+            self._top_k = max(self._top_k, limit)
+        return keyword
+
+    async def _parse_relation_query(self) -> RelationQuery:
+        detected_entities = await self._get_detected_entities()
+        deleted_entity_groups = await self.fetcher.get_deleted_entity_groups()
+        meta_cache = await self.fetcher.get_entities_meta_cache()
+        deleted_entities = meta_cache.deleted_entities
+        return RelationQuery(
+            detected_entities=detected_entities,
+            deleted_entity_groups=deleted_entity_groups,
+            deleted_entities=deleted_entities,
+        )
+
+    async def _get_detected_entities(self) -> list[utils_pb2.RelationNode]:
+        detected_entities = await self.fetcher.get_detected_entities()
+        meta_cache = await self.fetcher.get_entities_meta_cache()
+        detected_entities = expand_entities(meta_cache, detected_entities)
+        return detected_entities
+
+    def _parse_sorting(self) -> tuple[search_models.SortOrder, search_models.SortField, Optional[int]]:
+        sort = self.item.sort
+        if len(self.item.query) == 0:
+            if sort is None:
+                sort = SortOptions(
+                    field=SortField.CREATED,
+                    order=SortOrder.DESC,
+                    limit=None,
+                )
+            elif sort.field not in INDEX_SORTABLE_FIELDS:
+                raise InvalidQueryError(
+                    "sort_field",
+                    f"Empty query can only be sorted by '{SortField.CREATED}' or"
+                    f" '{SortField.MODIFIED}' and sort limit won't be applied",
+                )
+        else:
+            if sort is None:
+                sort = SortOptions(
+                    field=SortField.SCORE,
+                    order=SortOrder.DESC,
+                    limit=None,
+                )
+            elif sort.field not in INDEX_SORTABLE_FIELDS and sort.limit is None:
+                raise InvalidQueryError(
+                    "sort_field",
+                    f"Sort by '{sort.field}' requires setting a sort limit",
+                )
+
+        # We need to ask for all and cut later
+        top_k = None
+        if sort and sort.limit is not None:
+            # As the index can't sort, we have to do it when merging. To
+            # have consistent results, we must limit them
+            top_k = sort.limit
+
+        return (sort.order, sort.field, top_k)
+
+    async def _parse_filters(self) -> Filters:
+        assert self._query is not None, "query must be parsed before filters"
+
+        has_old_filters = (
+            len(self.item.filters) > 0
+            or len(self.item.fields) > 0
+            or self.item.range_creation_start is not None
+            or self.item.range_creation_end is not None
+            or self.item.range_modification_start is not None
+            or self.item.range_modification_end is not None
+        )
+        if self.item.filter_expression is not None and has_old_filters:
+            raise InvalidQueryError("filter_expression", "Cannot mix old filters with filter_expression")
+
+        field_expr = None
+        paragraph_expr = None
+        filter_operator = nodereader_pb2.FilterOperator.AND
+
+        if has_old_filters:
+            old_filters = OldFilterParams(
+                label_filters=self.item.filters,
+                keyword_filters=[],
+                range_creation_start=self.item.range_creation_start,
+                range_creation_end=self.item.range_creation_end,
+                range_modification_start=self.item.range_modification_start,
+                range_modification_end=self.item.range_modification_end,
+                fields=self.item.fields,
+            )
+            field_expr, paragraph_expr = await parse_old_filters(old_filters, self.fetcher)
+
+        if self.item.filter_expression is not None:
+            if self.item.filter_expression.field:
+                field_expr = await parse_expression(self.item.filter_expression.field, self.kbid)
+            if self.item.filter_expression.paragraph:
+                paragraph_expr = await parse_expression(self.item.filter_expression.paragraph, self.kbid)
+            if self.item.filter_expression.operator == FilterExpression.Operator.OR:
+                filter_operator = nodereader_pb2.FilterOperator.OR
+            else:
+                filter_operator = nodereader_pb2.FilterOperator.AND
+
+        autofilter = None
+        if self.item.autofilter:
+            if self._query.relation is not None:
+                autofilter = self._query.relation.detected_entities
+            else:
+                autofilter = await self._get_detected_entities()
+
+        hidden = await filter_hidden_resources(self.kbid, self.item.show_hidden)
+
+        return Filters(
+            autofilter=autofilter,
+            facets=self.item.faceted,
+            field_expression=field_expr,
+            paragraph_expression=paragraph_expr,
+            filter_expression_operator=filter_operator,
+            security=self.item.security,
+            hidden=hidden,
+            with_duplicates=self.item.with_duplicates,
+        )

nucliadb/search/search/query_parser/parsers/unit_retrieval.py

@@ -0,0 +1,176 @@
+# 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 typing import Optional
+
+from nucliadb.search.search.filters import (
+    translate_label,
+)
+from nucliadb.search.search.metrics import (
+    node_features,
+    query_parser_observer,
+)
+from nucliadb.search.search.query import (
+    apply_entities_filter,
+    get_sort_field_proto,
+)
+from nucliadb.search.search.query_parser.filter_expression import add_and_expression
+from nucliadb.search.search.query_parser.models import ParsedQuery, PredictReranker, UnitRetrieval
+from nucliadb_models.labels import LABEL_HIDDEN, translate_system_to_alias_label
+from nucliadb_models.search import (
+    SortOrderMap,
+)
+from nucliadb_protos import nodereader_pb2, utils_pb2
+from nucliadb_protos.nodereader_pb2 import SearchRequest
+
+
+@query_parser_observer.wrap({"type": "convert_retrieval_to_proto"})
+async def convert_retrieval_to_proto(
+    parsed: ParsedQuery,
+) -> tuple[SearchRequest, bool, list[str], Optional[str]]:
+    request = SearchRequest()
+
+    ## queries
+
+    if parsed.retrieval.query.keyword and parsed.retrieval.query.fulltext:
+        assert parsed.retrieval.query.keyword == parsed.retrieval.query.fulltext, (
+            "search proto doesn't support different queries for fulltext and keyword search"
+        )
+
+    if parsed.retrieval.query.fulltext:
+        request.document = True
+        node_features.inc({"type": "documents"})
+    if parsed.retrieval.query.keyword:
+        request.paragraph = True
+        node_features.inc({"type": "paragraphs"})
+
+    text_query = parsed.retrieval.query.keyword or parsed.retrieval.query.fulltext
+    if text_query is not None:
+        request.min_score_bm25 = text_query.min_score
+
+        if text_query.is_synonyms_query:
+            request.advanced_query = text_query.query
+        else:
+            request.body = text_query.query
+
+        # sort order
+        sort_field = get_sort_field_proto(text_query.order_by)
+        if sort_field is not None:
+            request.order.sort_by = sort_field
+            request.order.type = SortOrderMap[text_query.sort]  # type: ignore
+
+    if parsed.retrieval.query.semantic:
+        node_features.inc({"type": "vectors"})
+
+        request.min_score_semantic = parsed.retrieval.query.semantic.min_score
+
+        query_vector = parsed.retrieval.query.semantic.query
+        if query_vector is not None:
+            request.vectorset = parsed.retrieval.query.semantic.vectorset
+            request.vector.extend(query_vector)
+
+    if parsed.retrieval.query.relation:
+        node_features.inc({"type": "relations"})
+
+        request.relation_subgraph.entry_points.extend(parsed.retrieval.query.relation.detected_entities)
+        request.relation_subgraph.depth = 1
+        request.relation_subgraph.deleted_groups.extend(
+            parsed.retrieval.query.relation.deleted_entity_groups
+        )
+        for group_id, deleted_entities in parsed.retrieval.query.relation.deleted_entities.items():
+            request.relation_subgraph.deleted_entities.append(
+                nodereader_pb2.EntitiesSubgraphRequest.DeletedEntities(
+                    node_subtype=group_id, node_values=deleted_entities
+                )
+            )
+
+    # filters
+
+    request.with_duplicates = parsed.retrieval.filters.with_duplicates
+
+    request.faceted.labels.extend([translate_label(facet) for facet in parsed.retrieval.filters.facets])
+
+    if (
+        parsed.retrieval.filters.security is not None
+        and len(parsed.retrieval.filters.security.groups) > 0
+    ):
+        security_pb = utils_pb2.Security()
+        for group_id in parsed.retrieval.filters.security.groups:
+            if group_id not in security_pb.access_groups:
+                security_pb.access_groups.append(group_id)
+        request.security.CopyFrom(security_pb)
+
+    if parsed.retrieval.filters.field_expression:
+        request.field_filter.CopyFrom(parsed.retrieval.filters.field_expression)
+    if parsed.retrieval.filters.paragraph_expression:
+        request.paragraph_filter.CopyFrom(parsed.retrieval.filters.paragraph_expression)
+    request.filter_operator = parsed.retrieval.filters.filter_expression_operator
+
+    autofilter = []
+    if parsed.retrieval.filters.autofilter:
+        entity_filters = apply_entities_filter(request, parsed.retrieval.filters.autofilter)
+        autofilter.extend([translate_system_to_alias_label(e) for e in entity_filters])
+
+    if parsed.retrieval.filters.hidden is not None:
+        expr = nodereader_pb2.FilterExpression()
+        if parsed.retrieval.filters.hidden:
+            expr.facet.facet = LABEL_HIDDEN
+        else:
+            expr.bool_not.facet.facet = LABEL_HIDDEN
+
+        add_and_expression(request.field_filter, expr)
+
+    # top_k
+
+    # Adjust requested page size depending on rank fusion and reranking algorithms.
+    #
+    # Some rerankers want more results than the requested by the user so
+    # reranking can have more choices.
+
+    rank_fusion_window = 0
+    if parsed.retrieval.rank_fusion is not None:
+        rank_fusion_window = parsed.retrieval.rank_fusion.window
+
+    reranker_window = 0
+    if parsed.retrieval.reranker is not None and isinstance(parsed.retrieval.reranker, PredictReranker):
+        reranker_window = parsed.retrieval.reranker.window
+
+    request.result_per_page = max(
+        request.result_per_page,
+        rank_fusion_window,
+        reranker_window,
+    )
+
+    # XXX: legacy values that were returned by QueryParser but not always
+    # needed. We should find a better abstraction
+
+    incomplete = is_incomplete(parsed.retrieval)
+
+    rephrased_query = None
+    if parsed.retrieval.query.semantic:
+        rephrased_query = await parsed.fetcher.get_rephrased_query()
+
+    return request, incomplete, autofilter, rephrased_query
+
+
+def is_incomplete(retrieval: UnitRetrieval) -> bool:
+    if retrieval.query.semantic is None:
+        return False
+    incomplete = retrieval.query.semantic.query is None or len(retrieval.query.semantic.query) == 0
+    return incomplete

nucliadb/search/search/rerankers.py

@@ -178,8 +178,10 @@ def get_reranker(reranker: parser_models.Reranker) -> Reranker:
     elif isinstance(reranker, parser_models.PredictReranker):
         algorithm = PredictReranker(reranker.window)
 
-    else:
-        raise ValueError(f"Unknown reranker requested: {reranker}")
+    else:  # pragma: nocover
+        # This is a trick so mypy generates an error if this branch can be reached,
+        # that is, if we are missing some ifs
+        _a: int = "a"
 
     return algorithm
 

{nucliadb-6.3.7.post4066.dist-info → nucliadb-6.3.7.post4068.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nucliadb
-Version: 6.3.7.post4066
+Version: 6.3.7.post4068
 Summary: NucliaDB
 Author-email: Nuclia <nucliadb@nuclia.com>
 License: AGPL
@@ -20,11 +20,11 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: <4,>=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: nucliadb-telemetry[all]>=6.3.7.post4066
-Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.3.7.post4066
-Requires-Dist: nucliadb-protos>=6.3.7.post4066
-Requires-Dist: nucliadb-models>=6.3.7.post4066
-Requires-Dist: nidx-protos>=6.3.7.post4066
+Requires-Dist: nucliadb-telemetry[all]>=6.3.7.post4068
+Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.3.7.post4068
+Requires-Dist: nucliadb-protos>=6.3.7.post4068
+Requires-Dist: nucliadb-models>=6.3.7.post4068
+Requires-Dist: nidx-protos>=6.3.7.post4068
 Requires-Dist: nucliadb-admin-assets>=1.0.0.post1224
 Requires-Dist: nuclia-models>=0.24.2
 Requires-Dist: uvicorn[standard]

{nucliadb-6.3.7.post4066.dist-info → nucliadb-6.3.7.post4068.dist-info}/RECORD

@@ -216,7 +216,7 @@ nucliadb/search/api/v1/graph.py,sha256=ItVpzJbqfDLjoIo2fTb2mKGCM1Z34sx7CBb3gNmj6
 nucliadb/search/api/v1/knowledgebox.py,sha256=rWhx3PYWryingu19qwwFDbVvVYynq5Ky23FSlzmTutQ,8721
 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=4WDuY0LdxycWX960MGUV5Yojnq2V5A5hxDnfaEsTW9Q,13985
+nucliadb/search/api/v1/search.py,sha256=9OR4jXryhDkTFCPeeXyxK_VKGKkUMn8i5q41f747AiI,12829
 nucliadb/search/api/v1/suggest.py,sha256=Pwyxyk3Vu7aKU8vl2_rKhuE40ngnjZwAXS1rAilPDtM,6506
 nucliadb/search/api/v1/summarize.py,sha256=VAHJvE6V3xUgEBfqNKhgoxmDqCvh30RnrEIBVhMcNLU,2499
 nucliadb/search/api/v1/utils.py,sha256=5Ve-frn7LAE2jqAgB85F8RSeqxDlyA08--gS-AdOLS4,1434
@@ -233,39 +233,43 @@ nucliadb/search/search/cut.py,sha256=ytY0_GY7ocNjfxTb4aosxEp4ZfhQNDP--JkhEMGD298
 nucliadb/search/search/exceptions.py,sha256=klGLgAGGrXcSGix_W6418ZBMqDchAIGjN77ofkOScEI,1039
 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=dGzk6gDN6xdtREhLcZxBX_rTppQ8O1WcSYJQE4r5h-o,10372
-nucliadb/search/search/find_merge.py,sha256=3FnzKFEnVemg6FO_6zveulbAU7klvsiPEBvLrpBBMg8,17450
+nucliadb/search/search/find.py,sha256=d3OufK9xPaGgSQ9RzER6VJ_rk-d_uly4ia452wmGiz8,8182
+nucliadb/search/search/find_merge.py,sha256=sS_0ZeTDs7AiWWuDmYos8mThG5XvaTE92DBoQOPHGTQ,17964
 nucliadb/search/search/graph_merge.py,sha256=OiUNiXOWwrUVKqStuRcoUJwvDbDYamqIgiAy_FwPdMI,3405
-nucliadb/search/search/graph_strategy.py,sha256=SPJdDHQcTFsNb1IEWdWzklC5j1Vv9igibo0dYQAgcy0,33113
+nucliadb/search/search/graph_strategy.py,sha256=hwof-jxYELI6EYmvccDViDda3urE6E7v24-_-IsEF3E,32916
 nucliadb/search/search/hydrator.py,sha256=-R37gCrGxkyaiHQalnTWHNG_FCx11Zucd7qA1vQCxuw,6985
 nucliadb/search/search/ingestion_agents.py,sha256=NeJr4EEX-bvFFMGvXOOwLv8uU7NuQ-ntJnnrhnKfMzY,3174
-nucliadb/search/search/merge.py,sha256=fh5WnA_xnXp-Iiq5Cud9hIGole7_0OW2b3Oymk32D6Y,22689
+nucliadb/search/search/merge.py,sha256=4tnTgljD7FKdQYX7frZ3qyu8-n9wNb7f6H6ulqq4sV8,23369
 nucliadb/search/search/metrics.py,sha256=HJVQPLOIwLuc733G4keqEgx1-Dcg97hyWGKZQTojiSE,2973
 nucliadb/search/search/paragraphs.py,sha256=pNAEiYqJGGUVcEf7xf-PFMVqz0PX4Qb-WNG-_zPGN2o,7799
 nucliadb/search/search/pgcatalog.py,sha256=s_J98fsX_RuFXwpejpkGqG-tD9ELuzz4YQ6U3ew5h2g,9313
 nucliadb/search/search/predict_proxy.py,sha256=IFI3v_ODz2_UU1XZnyaD391fE7-2C0npSmj_HmDvzS4,3123
-nucliadb/search/search/query.py,sha256=Obd84og7BQJ5zZd3iAc9kyndCTHv0ihSL3PO5GNljR4,30351
+nucliadb/search/search/query.py,sha256=B7KJCG1d4oX4M2WlecCuMc98QCygutsl1R980HyVx3M,11491
 nucliadb/search/search/rank_fusion.py,sha256=tRGo_KlsFsVx1CQEy1iqQ6f0T1Dq1kf0axDXHuuzvvM,6946
-nucliadb/search/search/rerankers.py,sha256=3vep4EOVNeDJGsMdx-1g6Ar4ZGJG3IHym3HkxnbwtAQ,7321
+nucliadb/search/search/rerankers.py,sha256=PvhExUb8zZYghiFHRgGotw6h6bU--Rft09wE8arvtAw,7424
 nucliadb/search/search/shards.py,sha256=OEtN1p9WX_cMX8t-myaafpmFAPTpUEOutR7z1sDuNcY,3242
 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=OLZOfVKAJmnVW7KiKIfDVjYJphkDRd7cMa5NwUQbT-8,37421
+nucliadb/search/search/chat/ask.py,sha256=nGReEt6MRfBibMxWuH3H7jw5ktK3OmSW9ixzx-CC23Y,37229
 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=Jnja-Ss7skgnnDY8BymVfdeYsFPnIQFL8tEvcRXTKUE,47356
-nucliadb/search/search/chat/query.py,sha256=ILWdd-0kaV97kR4wenwo4lX9K0GN-dXv957wL4CKvx8,16779
+nucliadb/search/search/chat/query.py,sha256=ScZd2-hX9m36A8JGxesN8F5NKZV4FTiF-tN585gxg1M,16806
 nucliadb/search/search/query_parser/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/search/search/query_parser/exceptions.py,sha256=szAOXUZ27oNY-OSa9t2hQ5HHkQQC0EX1FZz_LluJHJE,1224
-nucliadb/search/search/query_parser/fetcher.py,sha256=vrPgPnebWlrbx9fcelw7eHayEDptxnm9BP1F9LAEMws,15307
+nucliadb/search/search/query_parser/fetcher.py,sha256=SkvBRDfSKmuz-QygNKLAU4AhZhhDo1dnOZmt1zA28RA,16851
 nucliadb/search/search/query_parser/filter_expression.py,sha256=rws5vsKTofX2iMUK4yvjmLZFxtcbWbyhIcwen4j0rQg,6578
-nucliadb/search/search/query_parser/models.py,sha256=7czH-jHskl9axEnZV5XnQY8cyN_fs14Cpivzd5aaSxc,2686
+nucliadb/search/search/query_parser/models.py,sha256=gGE2E8mfzJ49rOkgBtyYrax2O9mZUYoH7iyxP5IhotU,4651
 nucliadb/search/search/query_parser/old_filters.py,sha256=-zbfN-RsXoj_DRjh3Lfp-wShwFXgkISawzVptVzja-A,9071
 nucliadb/search/search/query_parser/parsers/__init__.py,sha256=ySCNSdbesLXGZyR88919njulA6UE10_3PhqMG_Yj1o4,1034
+nucliadb/search/search/query_parser/parsers/ask.py,sha256=eTz8wS-EJHuAagR384h6TT64itymFZRpfZJGX8r6aZM,2771
 nucliadb/search/search/query_parser/parsers/catalog.py,sha256=XdBiTweGTQkj8m_V_i2xbwp7P5pPO8K1Tud692XKhMw,7149
-nucliadb/search/search/query_parser/parsers/find.py,sha256=5Hp3MIlzkf_NdzpBaNAIHS8gWm6CYZEzUMwmrrO9Z-k,4783
+nucliadb/search/search/query_parser/parsers/common.py,sha256=InUWq5cL_LBDptuibQiSMw-9OeByqymTTqW0dzp7rM0,6265
+nucliadb/search/search/query_parser/parsers/find.py,sha256=MHEcFcukGUT8UMeq3wmefnv-FIEslrLsGNrDjtSvQ5A,11262
 nucliadb/search/search/query_parser/parsers/graph.py,sha256=QJs-pybNXPsMSEkIHctb0Q0xQG-aArks8BtUxbJL5rU,9386
+nucliadb/search/search/query_parser/parsers/search.py,sha256=Qh_xVdLW-jGyD2xDfiRU0K7vDuPu_3JsZEWJn81TLHw,9805
+nucliadb/search/search/query_parser/parsers/unit_retrieval.py,sha256=2NS11DnSUqj3A58mZVMsVRkH00ah9S1lXgUvJZF8NCI,6773
 nucliadb/standalone/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/standalone/api_router.py,sha256=hgq9FXpihzgjHkwcVGfGCSwyXy67fqXTfLFHuINzIi0,5567
 nucliadb/standalone/app.py,sha256=mAApNK_iVsQgJyd-mtwCeZq5csSimwnXmlQGH9a70pE,5586
@@ -361,8 +365,8 @@ 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.3.7.post4066.dist-info/METADATA,sha256=T8ZXH-p7B8m-0u_vcif1of80-FT3pbxg4vfITXBMUno,4301
-nucliadb-6.3.7.post4066.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-nucliadb-6.3.7.post4066.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
-nucliadb-6.3.7.post4066.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
-nucliadb-6.3.7.post4066.dist-info/RECORD,,
+nucliadb-6.3.7.post4068.dist-info/METADATA,sha256=5s-XgWMQEi0Ea8TUODlJ7Us6DomG6DTvnWvJneE2I3Y,4301
+nucliadb-6.3.7.post4068.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+nucliadb-6.3.7.post4068.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
+nucliadb-6.3.7.post4068.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
+nucliadb-6.3.7.post4068.dist-info/RECORD,,