nucliadb 6.2.1.post3328__py3-none-any.whl → 6.2.1.post3331__py3-none-any.whl

nucliadb/search/api/v1/search.py

@@ -37,6 +37,7 @@ from nucliadb.search.search import cache
 from nucliadb.search.search.exceptions import InvalidQueryError
 from nucliadb.search.search.merge import merge_results
 from nucliadb.search.search.query import QueryParser
+from nucliadb.search.search.query_parser.old_filters import OldFilterParams
 from nucliadb.search.search.utils import (
     filter_hidden_resources,
     min_score_from_payload,
@@ -269,17 +270,19 @@ async def search(
         kbid=kbid,
         features=item.features,
         query=item.query,
-        label_filters=item.filters,
-        keyword_filters=[],
         faceted=item.faceted,
         sort=item.sort,
         top_k=item.top_k,
         min_score=item.min_score,
-        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,
-        fields=item.fields,
+        old_filters=OldFilterParams(
+            label_filters=item.filters,
+            keyword_filters=[],
+            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,
+            fields=item.fields,
+        ),
         user_vector=item.vector,
         vectorset=item.vectorset,
         with_duplicates=item.with_duplicates,

nucliadb/search/api/v1/suggest.py

@@ -133,7 +133,8 @@ async def suggest(
 ) -> KnowledgeboxSuggestResults:
     with cache.request_caches():
         hidden = await filter_hidden_resources(kbid, show_hidden)
-        pb_query = suggest_query_to_pb(
+        pb_query = await suggest_query_to_pb(
+            kbid,
             features,
             query,
             fields,

nucliadb/search/search/chat/ask.py

@@ -61,6 +61,7 @@ from nucliadb.search.search.exceptions import (
 from nucliadb.search.search.graph_strategy import get_graph_results
 from nucliadb.search.search.metrics import RAGMetrics
 from nucliadb.search.search.query import QueryParser
+from nucliadb.search.search.query_parser.old_filters import OldFilterParams
 from nucliadb.search.utilities import get_predict
 from nucliadb_models.search import (
     AnswerAskResponseItem,
@@ -787,8 +788,10 @@ async def retrieval_in_resource(
                 kbid=kbid,
                 features=[],
                 query="",
-                label_filters=ask_request.filters,
-                keyword_filters=ask_request.keyword_filters,
+                old_filters=OldFilterParams(
+                    label_filters=ask_request.filters,
+                    keyword_filters=ask_request.keyword_filters,
+                ),
                 top_k=0,
                 min_score=MinScore(),
             ),

nucliadb/search/search/find.py

@@ -39,6 +39,7 @@ from nucliadb.search.search.metrics import (
     RAGMetrics,
 )
 from nucliadb.search.search.query import QueryParser
+from nucliadb.search.search.query_parser.old_filters import OldFilterParams
 from nucliadb.search.search.query_parser.parser import parse_find
 from nucliadb.search.search.rank_fusion import (
     RankFusionAlgorithm,
@@ -272,23 +273,25 @@ async def query_parser_from_find_request(
         features=item.features,
         query=item.query,
         query_entities=item.query_entities,
-        label_filters=item.filters,
-        keyword_filters=item.keyword_filters,
         faceted=None,
         sort=None,
         top_k=item.top_k,
         min_score=item.min_score,
-        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,
-        fields=item.fields,
+        old_filters=OldFilterParams(
+            label_filters=item.filters,
+            keyword_filters=item.keyword_filters,
+            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,
+            fields=item.fields,
+            key_filters=item.resource_filters,
+        ),
         user_vector=item.vector,
         vectorset=item.vectorset,
         with_duplicates=item.with_duplicates,
         with_synonyms=item.with_synonyms,
         autofilter=item.autofilter,
-        key_filters=item.resource_filters,
         security=item.security,
         generative_model=generative_model,
         rephrase=item.rephrase,

nucliadb/search/search/query.py

@@ -21,24 +21,19 @@ import asyncio
 import json
 import string
 from datetime import datetime
-from typing import Any, Awaitable, Optional, Union
+from typing import Any, Awaitable, Optional
 
 from nucliadb.common import datamanagers
 from nucliadb.common.models_utils.from_proto import RelationNodeTypeMap
 from nucliadb.search import logger
 from nucliadb.search.predict import SendToPredictError
 from nucliadb.search.search.filters import (
-    convert_to_node_filters,
-    flatten_filter_literals,
-    has_classification_label_filters,
-    split_labels_by_type,
     translate_label,
-    translate_label_filters,
 )
 from nucliadb.search.search.metrics import (
     node_features,
 )
-from nucliadb.search.search.query_parser.fetcher import Fetcher, get_classification_labels
+from nucliadb.search.search.query_parser.fetcher import Fetcher
 from nucliadb.search.search.rank_fusion import (
     RankFusionAlgorithm,
 )
@@ -65,6 +60,7 @@ from nucliadb_protos import nodereader_pb2, utils_pb2
 from nucliadb_protos.noderesources_pb2 import Resource
 
 from .exceptions import InvalidQueryError
+from .query_parser.old_filters import OldFilterParams, parse_old_filters
 
 INDEX_SORTABLE_FIELDS = [
     SortField.CREATED,
@@ -92,25 +88,18 @@ class QueryParser:
         kbid: str,
         features: list[SearchOptions],
         query: str,
-        label_filters: Union[list[str], list[Filter]],
-        keyword_filters: Union[list[str], list[Filter]],
         top_k: int,
         min_score: MinScore,
+        old_filters: OldFilterParams,
         query_entities: Optional[list[KnowledgeGraphEntity]] = None,
         faceted: Optional[list[str]] = None,
         sort: Optional[SortOptions] = None,
-        range_creation_start: Optional[datetime] = None,
-        range_creation_end: Optional[datetime] = None,
-        range_modification_start: Optional[datetime] = None,
-        range_modification_end: Optional[datetime] = None,
-        fields: Optional[list[str]] = None,
         user_vector: Optional[list[float]] = None,
         vectorset: Optional[str] = None,
         with_duplicates: bool = False,
         with_status: Optional[ResourceProcessingStatus] = None,
         with_synonyms: bool = False,
         autofilter: bool = False,
-        key_filters: Optional[list[str]] = None,
         security: Optional[RequestSecurity] = None,
         generative_model: Optional[str] = None,
         rephrase: bool = False,
@@ -127,40 +116,28 @@ class QueryParser:
         self.hidden = hidden
         if self.hidden is not None:
             if self.hidden:
-                label_filters.append(Filter(all=[LABEL_HIDDEN]))  # type: ignore
+                old_filters.label_filters.append(Filter(all=[LABEL_HIDDEN]))  # type: ignore
             else:
-                label_filters.append(Filter(none=[LABEL_HIDDEN]))  # type: ignore
-
-        self.label_filters: dict[str, Any] = convert_to_node_filters(label_filters)
-        self.flat_label_filters: list[str] = []
-        self.keyword_filters: dict[str, Any] = convert_to_node_filters(keyword_filters)
+                old_filters.label_filters.append(Filter(none=[LABEL_HIDDEN]))  # type: ignore
         self.faceted = faceted or []
         self.top_k = top_k
         self.min_score = min_score
         self.sort = sort
-        self.range_creation_start = range_creation_start
-        self.range_creation_end = range_creation_end
-        self.range_modification_start = range_modification_start
-        self.range_modification_end = range_modification_end
-        self.fields = fields or []
         self.user_vector = user_vector
         self.vectorset = vectorset
         self.with_duplicates = with_duplicates
         self.with_status = with_status
         self.with_synonyms = with_synonyms
         self.autofilter = autofilter
-        self.key_filters = key_filters
         self.security = security
         self.generative_model = generative_model
         self.rephrase = rephrase
         self.rephrase_prompt = rephrase_prompt
         self.query_endpoint_used = False
-        if len(self.label_filters) > 0:
-            self.label_filters = translate_label_filters(self.label_filters)
-            self.flat_label_filters = flatten_filter_literals(self.label_filters)
         self.max_tokens = max_tokens
         self.rank_fusion = rank_fusion
         self.reranker = reranker
+        self.old_filters = old_filters
         self.fetcher = Fetcher(
             kbid=kbid,
             query=query,
@@ -197,7 +174,7 @@ class QueryParser:
         This will schedule concurrent tasks for different data that needs to be pulled
         for the sake of the query being performed
         """
-        if len(self.label_filters) > 0 and has_classification_label_filters(self.flat_label_filters):
+        if len(self.old_filters.label_filters) > 0:
             asyncio.ensure_future(self.fetcher.get_classification_labels())
 
         if self.has_vector_search and self.user_vector is None:
@@ -243,25 +220,7 @@ class QueryParser:
         return request, incomplete, autofilters, rephrased_query
 
     async def parse_filters(self, request: nodereader_pb2.SearchRequest) -> None:
-        if len(self.label_filters) > 0:
-            field_labels = self.flat_label_filters
-            paragraph_labels: list[str] = []
-            if has_classification_label_filters(self.flat_label_filters):
-                classification_labels = await self.fetcher.get_classification_labels()
-                field_labels, paragraph_labels = split_labels_by_type(
-                    self.flat_label_filters, classification_labels
-                )
-                check_supported_filters(self.label_filters, paragraph_labels)
-
-            request.filter.field_labels.extend(field_labels)
-            request.filter.paragraph_labels.extend(paragraph_labels)
-            request.filter.labels_expression = json.dumps(self.label_filters)
-
-        if len(self.keyword_filters) > 0:
-            request.filter.keywords_expression = json.dumps(self.keyword_filters)
-
         request.faceted.labels.extend([translate_label(facet) for facet in self.faceted])
-        request.fields.extend(self.fields)
 
         if self.security is not None and len(self.security.groups) > 0:
             security_pb = utils_pb2.Security()
@@ -270,24 +229,15 @@ class QueryParser:
                     security_pb.access_groups.append(group_id)
             request.security.CopyFrom(security_pb)
 
-        if self.key_filters is not None and len(self.key_filters) > 0:
-            request.key_filters.extend(self.key_filters)
-            node_features.inc({"type": "key_filters"})
-
         if self.with_status is not None:
             request.with_status = PROCESSING_STATUS_TO_PB_MAP[self.with_status]
 
-        if self.range_creation_start is not None:
-            request.timestamps.from_created.FromDatetime(self.range_creation_start)
-
-        if self.range_creation_end is not None:
-            request.timestamps.to_created.FromDatetime(self.range_creation_end)
-
-        if self.range_modification_start is not None:
-            request.timestamps.from_modified.FromDatetime(self.range_modification_start)
-
-        if self.range_modification_end is not None:
-            request.timestamps.to_modified.FromDatetime(self.range_modification_end)
+        if self.old_filters:
+            field_expr, paragraph_expr = await parse_old_filters(self.old_filters, self.fetcher)
+            if field_expr is not None:
+                request.field_filter.CopyFrom(field_expr)
+            if paragraph_expr is not None:
+                request.paragraph_filter.CopyFrom(paragraph_expr)
 
     def parse_sorting(self, request: nodereader_pb2.SearchRequest) -> None:
         if len(self.query) == 0:
@@ -533,39 +483,30 @@ async def paragraph_query_to_pb(
 
     request.body = query
 
-    # we don't have a specific filter only for resource_ids but key_filters
-    # parse "rid" and "rid/field" like ids, so it does the job
-    request.key_filters.append(rid)
-
-    if len(filters) > 0:
-        field_labels = filters
-        paragraph_labels: list[str] = []
-        if has_classification_label_filters(filters):
-            classification_labels = await get_classification_labels(kbid)
-            field_labels, paragraph_labels = split_labels_by_type(filters, classification_labels)
-        request.filter.field_labels.extend(field_labels)
-        request.filter.paragraph_labels.extend(paragraph_labels)
-
-    request.faceted.labels.extend([translate_label(facet) for facet in faceted])
-    request.fields.extend(fields)
-
-    if sort:
-        request.order.field = sort
-        request.order.type = sort_ord  # type: ignore
-
-    request.with_duplicates = with_duplicates
-
-    if range_creation_start is not None:
-        request.timestamps.from_created.FromDatetime(range_creation_start)
-
-    if range_creation_end is not None:
-        request.timestamps.to_created.FromDatetime(range_creation_end)
-
-    if range_modification_start is not None:
-        request.timestamps.from_modified.FromDatetime(range_modification_start)
-
-    if range_modification_end is not None:
-        request.timestamps.to_modified.FromDatetime(range_modification_end)
+    old = OldFilterParams(
+        label_filters=filters,
+        keyword_filters=[],
+        range_creation_start=range_creation_start,
+        range_creation_end=range_creation_end,
+        range_modification_start=range_modification_start,
+        range_modification_end=range_modification_end,
+        key_filters=[rid],
+        fields=fields,
+    )
+    fetcher = Fetcher(
+        kbid,
+        query="",
+        user_vector=None,
+        vectorset=None,
+        rephrase=False,
+        rephrase_prompt=None,
+        generative_model=None,
+    )
+    field_expr, paragraph_expr = await parse_old_filters(old, fetcher)
+    if field_expr is not None:
+        request.field_filter.CopyFrom(field_expr)
+    if paragraph_expr is not None:
+        request.paragraph_filter.CopyFrom(paragraph_expr)
 
     return request
 
@@ -643,7 +584,8 @@ def parse_entities_to_filters(
     return added_filters
 
 
-def suggest_query_to_pb(
+async def suggest_query_to_pb(
+    kbid: str,
     features: list[SuggestOptions],
     query: str,
     fields: list[str],
@@ -663,29 +605,34 @@ def suggest_query_to_pb(
 
     if SuggestOptions.PARAGRAPH in features:
         request.features.append(nodereader_pb2.SuggestFeatures.PARAGRAPHS)
-        request.fields.extend(fields)
 
-        if hidden is not None:
-            if hidden:
-                filters.append(Filter(all=[LABEL_HIDDEN]))  # type: ignore
-            else:
-                filters.append(Filter(none=[LABEL_HIDDEN]))  # type: ignore
-
-        expression = convert_to_node_filters(filters)
-        if expression:
-            expression = translate_label_filters(expression)
-
-        request.filter.field_labels.extend(flatten_filter_literals(expression))
-        request.filter.labels_expression = json.dumps(expression)
-
-    if range_creation_start is not None:
-        request.timestamps.from_created.FromDatetime(range_creation_start)
-    if range_creation_end is not None:
-        request.timestamps.to_created.FromDatetime(range_creation_end)
-    if range_modification_start is not None:
-        request.timestamps.from_modified.FromDatetime(range_modification_start)
-    if range_modification_end is not None:
-        request.timestamps.to_modified.FromDatetime(range_modification_end)
+    if hidden is not None:
+        if hidden:
+            filters.append(Filter(all=[LABEL_HIDDEN]))  # type: ignore
+        else:
+            filters.append(Filter(none=[LABEL_HIDDEN]))  # type: ignore
+
+    old = OldFilterParams(
+        label_filters=filters,
+        keyword_filters=[],
+        range_creation_start=range_creation_start,
+        range_creation_end=range_creation_end,
+        range_modification_start=range_modification_start,
+        range_modification_end=range_modification_end,
+        fields=fields,
+    )
+    fetcher = Fetcher(
+        kbid,
+        query="",
+        user_vector=None,
+        vectorset=None,
+        rephrase=False,
+        rephrase_prompt=None,
+        generative_model=None,
+    )
+    field_expr, _ = await parse_old_filters(old, fetcher)
+    if field_expr is not None:
+        request.field_filter.CopyFrom(field_expr)
 
     return request
 

nucliadb/search/search/query_parser/old_filters.py

@@ -0,0 +1,260 @@
+# 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 dataclasses import dataclass
+from datetime import datetime
+from typing import Optional, Union
+
+from nucliadb.search.search.filters import translate_label
+from nucliadb_models.search import (
+    Filter,
+)
+from nucliadb_protos import knowledgebox_pb2
+from nucliadb_protos.nodereader_pb2 import FilterExpression
+
+from .exceptions import InvalidQueryError
+from .fetcher import Fetcher
+
+
+@dataclass
+class OldFilterParams:
+    label_filters: Union[list[str], list[Filter]]
+    keyword_filters: Union[list[str], list[Filter]]
+    range_creation_start: Optional[datetime] = None
+    range_creation_end: Optional[datetime] = None
+    range_modification_start: Optional[datetime] = None
+    range_modification_end: Optional[datetime] = None
+    fields: Optional[list[str]] = None
+    key_filters: Optional[list[str]] = None
+
+
+async def parse_old_filters(
+    old: OldFilterParams, fetcher: Fetcher
+) -> tuple[Optional[FilterExpression], Optional[FilterExpression]]:
+    filters = []
+    paragraph_filter_expression = None
+
+    # Labels
+    if old.label_filters:
+        classification_labels = await fetcher.get_classification_labels()
+
+        paragraph_exprs = []
+        for fltr in old.label_filters:
+            field_expr, paragraph_expr = convert_label_filter_to_expressions(fltr, classification_labels)
+            if field_expr:
+                filters.append(field_expr)
+            if paragraph_expr:
+                paragraph_exprs.append(paragraph_expr)
+
+        if len(paragraph_exprs) == 1:
+            paragraph_filter_expression = paragraph_exprs[0]
+        elif len(paragraph_exprs) > 1:
+            paragraph_filter_expression = FilterExpression()
+            paragraph_filter_expression.bool_and.operands.extend(paragraph_exprs)
+
+    # Keywords
+    if old.keyword_filters:
+        for fltr in old.keyword_filters:
+            filters.append(convert_keyword_filter_to_expression(fltr))
+
+    # Timestamps
+    if old.range_creation_start is not None or old.range_creation_end is not None:
+        f = FilterExpression()
+        f.date.field = FilterExpression.DateRangeFilter.DateField.CREATED
+        if old.range_creation_start is not None:
+            f.date.since.FromDatetime(old.range_creation_start)
+        if old.range_creation_end is not None:
+            f.date.until.FromDatetime(old.range_creation_end)
+        filters.append(f)
+
+    if old.range_modification_start is not None or old.range_modification_end is not None:
+        f = FilterExpression()
+        f.date.field = FilterExpression.DateRangeFilter.DateField.MODIFIED
+        if old.range_modification_start is not None:
+            f.date.since.FromDatetime(old.range_modification_start)
+        if old.range_modification_end is not None:
+            f.date.until.FromDatetime(old.range_modification_end)
+        filters.append(f)
+
+    # Fields
+    if old.fields:
+        field_filters = []
+        for field in old.fields:
+            parts = field.split("/")
+            f = FilterExpression()
+            f.field.field_type = parts[0]
+            if len(parts) > 1:
+                f.field.field_id = parts[1]
+            field_filters.append(f)
+
+        if len(field_filters) > 1:
+            f = FilterExpression()
+            f.bool_or.operands.extend(field_filters)
+            filters.append(f)
+        else:
+            filters.append(field_filters[0])
+
+    # Key filter
+    if old.key_filters:
+        key_exprs = []
+        for key in old.key_filters:
+            expr = FilterExpression()
+            parts = key.split("/")
+            if len(parts) == 1:
+                expr.resource.resource_id = parts[0]
+            else:
+                r = FilterExpression()
+                r.resource.resource_id = parts[0]
+                expr.bool_and.operands.append(r)
+                f = FilterExpression()
+                f.field.field_type = parts[1]
+                if len(parts) > 2:
+                    f.field.field_id = parts[2]
+            key_exprs.append(expr)
+
+        if len(key_exprs) == 1:
+            filters.append(key_exprs[0])
+        elif len(key_exprs) > 1:
+            f = FilterExpression()
+            f.bool_or.operands.extend(key_exprs)
+            filters.append(f)
+
+    # Build filter
+    if len(filters) == 0:
+        return None, paragraph_filter_expression
+    elif len(filters) == 1:
+        return filters[0], paragraph_filter_expression
+    else:
+        f = FilterExpression()
+        f.bool_and.operands.extend(filters)
+        return f, paragraph_filter_expression
+
+
+def convert_label_filter_to_expressions(
+    fltr: Union[str, Filter], classification_labels: knowledgebox_pb2.Labels
+) -> tuple[Optional[FilterExpression], Optional[FilterExpression]]:
+    if isinstance(fltr, str):
+        fltr = translate_label(fltr)
+        f = FilterExpression()
+        f.facet.facet = fltr
+        if is_paragraph_label(fltr, classification_labels):
+            return None, f
+        else:
+            return f, None
+
+    if fltr.all:
+        return split_labels(fltr.all, classification_labels, "bool_and", negate=False)
+    if fltr.any:
+        return split_labels(fltr.any, classification_labels, "bool_or", negate=False)
+    if fltr.none:
+        return split_labels(fltr.none, classification_labels, "bool_and", negate=True)
+    if fltr.not_all:
+        return split_labels(fltr.not_all, classification_labels, "bool_or", negate=True)
+
+    return None, None
+
+
+def split_labels(
+    labels: list[str], classification_labels: knowledgebox_pb2.Labels, combinator: str, negate: bool
+) -> tuple[Optional[FilterExpression], Optional[FilterExpression]]:
+    field = []
+    paragraph = []
+    for label in labels:
+        label = translate_label(label)
+        expr = FilterExpression()
+        if negate:
+            expr.bool_not.facet.facet = label
+        else:
+            expr.facet.facet = label
+
+        if is_paragraph_label(label, classification_labels):
+            paragraph.append(expr)
+        else:
+            field.append(expr)
+
+    if len(field) == 0:
+        field_expr = None
+    elif len(field) == 1:
+        field_expr = field[0]
+    else:
+        field_expr = FilterExpression()
+        filter_list = getattr(field_expr, combinator)
+        filter_list.operands.extend(field)
+
+    if len(paragraph) > 0 and combinator == "bool_or":
+        raise InvalidQueryError(
+            "filters",
+            "Paragraph labels can only be used with 'all' filter",
+        )
+
+    if len(paragraph) == 0:
+        paragraph_expr = None
+    elif len(paragraph) == 1:
+        paragraph_expr = paragraph[0]
+    else:
+        paragraph_expr = FilterExpression()
+        filter_list = getattr(paragraph_expr, combinator)
+        filter_list.extend(paragraph)
+
+    return field_expr, paragraph_expr
+
+
+def is_paragraph_label(label: str, classification_labels: knowledgebox_pb2.Labels) -> bool:
+    if len(label) == 0 or label[0] != "/":
+        return False
+    if not label.startswith("/l/"):
+        return False
+    # Classification labels should have the form /l/labelset/label
+    parts = label.split("/")
+    if len(parts) < 4:
+        return False
+    labelset_id = parts[2]
+
+    try:
+        labelset: Optional[knowledgebox_pb2.LabelSet] = classification_labels.labelset.get(labelset_id)
+        if labelset is None:
+            return False
+        return knowledgebox_pb2.LabelSet.LabelSetKind.PARAGRAPHS in labelset.kind
+    except KeyError:
+        # labelset_id not found
+        return False
+
+
+def convert_keyword_filter_to_expression(fltr: Union[str, Filter]) -> FilterExpression:
+    if isinstance(fltr, str):
+        return convert_keyword_to_expression(fltr)
+
+    f = FilterExpression()
+    if fltr.all:
+        f.bool_and.operands.extend((convert_keyword_to_expression(f) for f in fltr.all))
+    if fltr.any:
+        f.bool_or.operands.extend((convert_keyword_to_expression(f) for f in fltr.any))
+    if fltr.none:
+        f.bool_not.bool_or.operands.extend((convert_keyword_to_expression(f) for f in fltr.none))
+    if fltr.not_all:
+        f.bool_not.bool_and.operands.extend((convert_keyword_to_expression(f) for f in fltr.not_all))
+
+    return f
+
+
+def convert_keyword_to_expression(keyword: str) -> FilterExpression:
+    f = FilterExpression()
+    f.keyword.keyword = keyword
+    return f

{nucliadb-6.2.1.post3328.dist-info → nucliadb-6.2.1.post3331.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nucliadb
-Version: 6.2.1.post3328
+Version: 6.2.1.post3331
 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.2.1.post3328
-Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.2.1.post3328
-Requires-Dist: nucliadb-protos>=6.2.1.post3328
-Requires-Dist: nucliadb-models>=6.2.1.post3328
-Requires-Dist: nidx-protos>=6.2.1.post3328
+Requires-Dist: nucliadb-telemetry[all]>=6.2.1.post3331
+Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.2.1.post3331
+Requires-Dist: nucliadb-protos>=6.2.1.post3331
+Requires-Dist: nucliadb-models>=6.2.1.post3331
+Requires-Dist: nidx-protos>=6.2.1.post3331
 Requires-Dist: nucliadb-admin-assets>=1.0.0.post1224
 Requires-Dist: nuclia-models>=0.24.2
 Requires-Dist: uvicorn

{nucliadb-6.2.1.post3328.dist-info → nucliadb-6.2.1.post3331.dist-info}/RECORD

@@ -196,8 +196,8 @@ nucliadb/search/api/v1/find.py,sha256=DsnWkySu_cFajDWJIxN8DYvLL_Rm2yiCjHD8TsqPfR
 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=k80su3UaucHiYflQFSilW10QW4ZxRVRp0kT8zrJXbcU,13498
-nucliadb/search/api/v1/suggest.py,sha256=S0YUTAWukzZSYZJzN3T5MUgPM3599HQvG76GOCBuAbQ,5907
+nucliadb/search/api/v1/search.py,sha256=CBszxidsfoLmrCbVL8cuZboWJlmt_GAfpjix0Tdp_yA,13650
+nucliadb/search/api/v1/suggest.py,sha256=Cc1vvT5AFEq0j6_IAx5jSVekMJpIi6kY-DWhzi7vkLg,5931
 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
@@ -213,7 +213,7 @@ 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=AocqiH_mWvF_szUaW0ONqWrZAbX-k_VhM0Lpv7D669M,10030
+nucliadb/search/search/find.py,sha256=BC_5p3oRKeQBVmuFCDdCd36Qr2TqJZPIjC0XfRuDJWU,10186
 nucliadb/search/search/find_merge.py,sha256=3FnzKFEnVemg6FO_6zveulbAU7klvsiPEBvLrpBBMg8,17450
 nucliadb/search/search/graph_strategy.py,sha256=ahwcUTQZ0Ll-rnS285DO9PmRyiM-1p4BM3UvmOYVwhM,31750
 nucliadb/search/search/hydrator.py,sha256=-R37gCrGxkyaiHQalnTWHNG_FCx11Zucd7qA1vQCxuw,6985
@@ -223,14 +223,14 @@ nucliadb/search/search/metrics.py,sha256=81X-tahGW4n2CLvUzCPdNxNClmZqUWZjcVOGCUH
 nucliadb/search/search/paragraphs.py,sha256=pNAEiYqJGGUVcEf7xf-PFMVqz0PX4Qb-WNG-_zPGN2o,7799
 nucliadb/search/search/pgcatalog.py,sha256=IaNK4dAxdXs38PoIkTdgqMDuZDjeiOtcXn3LeaT-OMw,8855
 nucliadb/search/search/predict_proxy.py,sha256=xBlh6kjuQpWRq7KsBx4pEl2PtnwljjQIiYMaTWpcCSA,3015
-nucliadb/search/search/query.py,sha256=AlhRw4Mick4Oab5HsKHaQpBXsVc_UUY5IpkUIwsFfU8,30577
+nucliadb/search/search/query.py,sha256=vSnnqJPB5iHI7kugaL6boH1l4j5HV6ln4EKbskJnFWw,27346
 nucliadb/search/search/rank_fusion.py,sha256=tRGo_KlsFsVx1CQEy1iqQ6f0T1Dq1kf0axDXHuuzvvM,6946
 nucliadb/search/search/rerankers.py,sha256=3vep4EOVNeDJGsMdx-1g6Ar4ZGJG3IHym3HkxnbwtAQ,7321
 nucliadb/search/search/shards.py,sha256=JSRSrHgHcF4sXyuZZoJdMfK0v_LHpoSRf1lCr5-K5ko,2742
 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=SfnixWdSdwCE8o8zN0_bYpRuqw0VPc62DF4Wbft_GvQ,36303
+nucliadb/search/search/chat/ask.py,sha256=q0CSXQJs69z52XWleIklcn5_bvHJQT7z94XUqKW506Y,36451
 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
@@ -239,6 +239,7 @@ nucliadb/search/search/query_parser/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyv
 nucliadb/search/search/query_parser/exceptions.py,sha256=szAOXUZ27oNY-OSa9t2hQ5HHkQQC0EX1FZz_LluJHJE,1224
 nucliadb/search/search/query_parser/fetcher.py,sha256=jhr__J0KmAzjdsTTadWQmD9qf6lZvqlKAfZdYjZH_UY,15742
 nucliadb/search/search/query_parser/models.py,sha256=2iWuTcH24RDF8xokgXr0j5qbMoURQ1TFyqJIYs16LqU,2283
+nucliadb/search/search/query_parser/old_filters.py,sha256=-zbfN-RsXoj_DRjh3Lfp-wShwFXgkISawzVptVzja-A,9071
 nucliadb/search/search/query_parser/parser.py,sha256=m6meq5QQO_ofdtbrvEORsZLjxURWfRR0dINrgDXmYRg,6323
 nucliadb/standalone/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/standalone/api_router.py,sha256=4-g-eEq27nL6vKCLRCoV0Pxf-L273N-eHeEX2vI9qgg,6215
@@ -335,8 +336,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.2.1.post3328.dist-info/METADATA,sha256=BIvljbBrmj9EjvUGSuI1e3xmkgAAUtfIy023SRqCKO8,4291
-nucliadb-6.2.1.post3328.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nucliadb-6.2.1.post3328.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
-nucliadb-6.2.1.post3328.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
-nucliadb-6.2.1.post3328.dist-info/RECORD,,
+nucliadb-6.2.1.post3331.dist-info/METADATA,sha256=SRTN3yRk9RMQE2QmoZnEDVQOkAEfcT-YqNUbXYbn_rc,4291
+nucliadb-6.2.1.post3331.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nucliadb-6.2.1.post3331.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
+nucliadb-6.2.1.post3331.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
+nucliadb-6.2.1.post3331.dist-info/RECORD,,