nucliadb 6.3.0.post3417__py3-none-any.whl → 6.3.0.post3421__py3-none-any.whl

nucliadb/search/api/v1/catalog.py

@@ -17,11 +17,13 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
+import json
 from time import time
 from typing import Optional, Union
 
 from fastapi import Request, Response
 from fastapi_versioning import version
+from pydantic import ValidationError
 
 from nucliadb.common.datamanagers.exceptions import KnowledgeBoxNotFound
 from nucliadb.common.maindb.pg import PGDriver
@@ -34,11 +36,12 @@ 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.query_parser.catalog import parse_catalog
 from nucliadb.search.search.utils import (
     maybe_log_request_payload,
 )
 from nucliadb_models.common import FieldTypeName
+from nucliadb_models.filters import CatalogFilterExpression
 from nucliadb_models.metadata import ResourceProcessingStatus
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.search import (
@@ -72,6 +75,9 @@ async def catalog_get(
     response: Response,
     kbid: str,
     query: str = fastapi_query(SearchParamDefaults.query),
+    filter_expression: Optional[str] = fastapi_query(
+        SearchParamDefaults.catalog_filter_expression, include_in_schema=False
+    ),
     filters: list[str] = fastapi_query(SearchParamDefaults.filters),
     faceted: list[str] = fastapi_query(SearchParamDefaults.faceted),
     sort_field: SortField = fastapi_query(SearchParamDefaults.sort_field),
@@ -93,8 +99,17 @@ async def catalog_get(
     ),
     hidden: Optional[bool] = fastapi_query(SearchParamDefaults.hidden),
 ) -> Union[KnowledgeboxSearchResults, HTTPClientError]:
+    try:
+        expr = (
+            CatalogFilterExpression.model_validate_json(filter_expression) if filter_expression else None
+        )
+    except ValidationError as exc:
+        detail = json.loads(exc.json())
+        return HTTPClientError(status_code=422, detail=detail)
+
     item = CatalogRequest(
         query=query,
+        filter_expression=expr,
         filters=filters,
         faceted=faceted,
         page_number=page_number,
@@ -147,7 +162,7 @@ async def catalog(
     start_time = time()
     try:
         with cache.request_caches():
-            query_parser = parse_catalog(kbid, item)
+            query_parser = await parse_catalog(kbid, item)
 
             catalog_results = CatalogResponse()
             catalog_results.fulltext = await pgcatalog_search(query_parser)

nucliadb/search/api/v1/find.py

@@ -35,7 +35,7 @@ from nucliadb.search.search.exceptions import InvalidQueryError
 from nucliadb.search.search.find import find
 from nucliadb.search.search.utils import maybe_log_request_payload, min_score_from_query_params
 from nucliadb_models.common import FieldTypeName
-from nucliadb_models.filter import FilterExpression
+from nucliadb_models.filters import FilterExpression
 from nucliadb_models.resource import ExtractedDataTypeName, NucliaDBRoles
 from nucliadb_models.search import (
     FindRequest,

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

@@ -32,7 +32,7 @@ from nucliadb.search.search import cache
 from nucliadb.search.search.exceptions import InvalidQueryError
 from nucliadb.search.search.merge import merge_paragraphs_results
 from nucliadb.search.search.query import paragraph_query_to_pb
-from nucliadb_models.filter import FilterExpression
+from nucliadb_models.filters import FilterExpression
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.search import (
     NucliaDBClientType,

nucliadb/search/api/v1/search.py

@@ -45,7 +45,7 @@ from nucliadb.search.search.utils import (
     should_disable_vector_search,
 )
 from nucliadb_models.common import FieldTypeName
-from nucliadb_models.filter import FilterExpression
+from nucliadb_models.filters import FilterExpression
 from nucliadb_models.metadata import ResourceProcessingStatus
 from nucliadb_models.resource import ExtractedDataTypeName, NucliaDBRoles
 from nucliadb_models.search import (

nucliadb/search/api/v1/suggest.py

@@ -35,7 +35,7 @@ from nucliadb.search.search.merge import merge_suggest_results
 from nucliadb.search.search.query import suggest_query_to_pb
 from nucliadb.search.search.utils import filter_hidden_resources
 from nucliadb_models.common import FieldTypeName
-from nucliadb_models.filter import FilterExpression
+from nucliadb_models.filters import FilterExpression
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.search import (
     KnowledgeboxSuggestResults,

nucliadb/search/search/chat/query.py

@@ -32,7 +32,7 @@ from nucliadb.search.search.metrics import RAGMetrics
 from nucliadb.search.search.query import QueryParser
 from nucliadb.search.settings import settings
 from nucliadb.search.utilities import get_predict
-from nucliadb_models import filter
+from nucliadb_models import filters
 from nucliadb_models.search import (
     AskRequest,
     ChatContextMessage,
@@ -159,17 +159,17 @@ def add_resource_filter(request: Union[FindRequest, AskRequest], resources: list
 
     if request.filter_expression is not None:
         if len(resources) > 1:
-            resource_filter: filter.FieldFilterExpression = filter.Or.model_validate(
-                {"or": [filter.Resource(prop="resource", id=rid) for rid in resources]}
+            resource_filter: filters.FieldFilterExpression = filters.Or.model_validate(
+                {"or": [filters.Resource(prop="resource", id=rid) for rid in resources]}
             )
         else:
-            resource_filter = filter.Resource(prop="resource", id=resources[0])
+            resource_filter = filters.Resource(prop="resource", id=resources[0])
 
         # Add to filter expression if set
         if request.filter_expression.field is None:
             request.filter_expression.field = resource_filter
         else:
-            request.filter_expression.field = filter.And.model_validate(
+            request.filter_expression.field = filters.And.model_validate(
                 {"and": [request.filter_expression.field, resource_filter]}
             )
     else:

nucliadb/search/search/pgcatalog.py

@@ -20,15 +20,14 @@
 
 import logging
 from collections import defaultdict
-from typing import Any, cast
+from typing import Any, Literal, Union, cast
 
 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.search.search.query_parser.models import CatalogExpression, CatalogQuery
 from nucliadb_models.labels import translate_system_to_alias_label
-from nucliadb_models.metadata import ResourceProcessingStatus
 from nucliadb_models.search import (
     ResourceResult,
     Resources,
@@ -43,40 +42,73 @@ observer = metrics.Observer("pg_catalog_search", labels={"op": ""})
 logger = logging.getLogger(__name__)
 
 
-def _filter_operands(operands):
-    literals = []
-    nonliterals = []
-    for operand in operands:
-        op, params = next(iter(operand.items()))
-        if op == "literal":
-            literals.append(params)
+def _filter_operands(operands: list[CatalogExpression]) -> tuple[list[str], list[CatalogExpression]]:
+    facets = []
+    nonfacets = []
+    for op in operands:
+        if op.facet:
+            facets.append(op.facet)
         else:
-            nonliterals.append(operand)
+            nonfacets.append(op)
 
-    return literals, nonliterals
+    return facets, nonfacets
 
 
-def _convert_filter(filter, filter_params):
-    op, operands = next(iter(filter.items()))
-    if op == "literal":
+def _convert_filter(expr: CatalogExpression, filter_params: dict[str, Any]) -> str:
+    if expr.bool_and:
+        return _convert_boolean_op(expr.bool_and, "and", filter_params)
+    elif expr.bool_or:
+        return _convert_boolean_op(expr.bool_or, "or", filter_params)
+    elif expr.bool_not:
+        return f"(NOT {_convert_filter(expr.bool_not, filter_params)})"
+    elif expr.date:
+        return _convert_date_filter(expr.date, filter_params)
+    elif expr.facet:
         param_name = f"param{len(filter_params)}"
-        filter_params[param_name] = [operands]
+        filter_params[param_name] = [expr.facet]
         return f"extract_facets(labels) @> %({param_name})s"
-    elif op in ("and", "or"):
-        array_op = "@>" if op == "and" else "&&"
-        sql = []
-        literals, nonliterals = _filter_operands(operands)
-        if literals:
-            param_name = f"param{len(filter_params)}"
-            filter_params[param_name] = literals
-            sql.append(f"extract_facets(labels) {array_op} %({param_name})s")
-        for nonlit in nonliterals:
-            sql.append(_convert_filter(nonlit, filter_params))
-        return "(" + f" {op.upper()} ".join(sql) + ")"
-    elif op == "not":
-        return f"(NOT {_convert_filter(operands, filter_params)})"
+    elif expr.resource_id:
+        param_name = f"param{len(filter_params)}"
+        filter_params[param_name] = [expr.resource_id]
+        return f"rid = %({param_name})s"
+    else:
+        return ""
+
+
+def _convert_boolean_op(
+    operands: list[CatalogExpression],
+    op: Union[Literal["and"], Literal["or"]],
+    filter_params: dict[str, Any],
+) -> str:
+    array_op = "@>" if op == "and" else "&&"
+    sql = []
+    facets, nonfacets = _filter_operands(operands)
+    if facets:
+        param_name = f"param{len(filter_params)}"
+        filter_params[param_name] = facets
+        sql.append(f"extract_facets(labels) {array_op} %({param_name})s")
+    for nonfacet in nonfacets:
+        sql.append(_convert_filter(nonfacet, filter_params))
+    return "(" + f" {op.upper()} ".join(sql) + ")"
+
+
+def _convert_date_filter(date: CatalogExpression.Date, filter_params: dict[str, Any]) -> str:
+    if date.since and date.until:
+        since_name = f"param{len(filter_params)}"
+        filter_params[since_name] = date.since
+        until_name = f"param{len(filter_params)}"
+        filter_params[until_name] = date.until
+        return f"{date.field} BETWEEN %({since_name})s AND %({until_name})s"
+    elif date.since:
+        since_name = f"param{len(filter_params)}"
+        filter_params[since_name] = date.since
+        return f"{date.field} > %({since_name})s"
+    elif date.until:
+        until_name = f"param{len(filter_params)}"
+        filter_params[until_name] = date.until
+        return f"{date.field} < %({until_name})s"
     else:
-        raise ValueError(f"Invalid operator {op}")
+        raise ValueError(f"Invalid date operator")
 
 
 def _prepare_query(catalog_query: CatalogQuery):
@@ -92,24 +124,8 @@ def _prepare_query(catalog_query: CatalogQuery):
         )
         filter_params["query"] = catalog_query.query
 
-    if catalog_query.filters.creation.after:
-        filter_sql.append("created_at > %(created_at_start)s")
-        filter_params["created_at_start"] = catalog_query.filters.creation.after
-
-    if catalog_query.filters.creation.before:
-        filter_sql.append("created_at < %(created_at_end)s")
-        filter_params["created_at_end"] = catalog_query.filters.creation.before
-
-    if catalog_query.filters.modification.after:
-        filter_sql.append("modified_at > %(modified_at_start)s")
-        filter_params["modified_at_start"] = catalog_query.filters.modification.after
-
-    if catalog_query.filters.modification.before:
-        filter_sql.append("modified_at < %(modified_at_end)s")
-        filter_params["modified_at_end"] = catalog_query.filters.modification.before
-
-    if catalog_query.filters.labels:
-        filter_sql.append(_convert_filter(catalog_query.filters.labels, filter_params))
+    if catalog_query.filters:
+        filter_sql.append(_convert_filter(catalog_query.filters, filter_params))
 
     order_sql = ""
     if catalog_query.sort:
@@ -130,13 +146,6 @@ def _prepare_query(catalog_query: CatalogQuery):
 
         order_sql = f" ORDER BY {order_field} {order_dir}"
 
-    if catalog_query.filters.with_status:
-        filter_sql.append("labels && %(status)s")
-        if catalog_query.filters.with_status == ResourceProcessingStatus.PROCESSED:
-            filter_params["status"] = ["/n/s/PROCESSED", "/n/s/ERROR"]
-        else:
-            filter_params["status"] = ["/n/s/PENDING"]
-
     return (
         f"SELECT * FROM catalog WHERE {' AND '.join(filter_sql)}{order_sql}",
         filter_params,

nucliadb/search/search/query.py

@@ -39,7 +39,7 @@ from nucliadb.search.search.rank_fusion import (
 from nucliadb.search.search.rerankers import (
     Reranker,
 )
-from nucliadb_models.filter import FilterExpression
+from nucliadb_models.filters import FilterExpression
 from nucliadb_models.internal.predict import QueryInfo
 from nucliadb_models.labels import LABEL_HIDDEN, translate_system_to_alias_label
 from nucliadb_models.metadata import ResourceProcessingStatus

nucliadb/search/search/query_parser/catalog.py

@@ -0,0 +1,190 @@
+# 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 nucliadb.common import datamanagers
+from nucliadb.search.search.exceptions import InvalidQueryError
+from nucliadb.search.search.filters import translate_label
+from nucliadb.search.search.query_parser.models import (
+    CatalogExpression,
+    CatalogQuery,
+)
+from nucliadb_models import search as search_models
+from nucliadb_models.filters import (
+    And,
+    DateCreated,
+    DateModified,
+    Not,
+    Or,
+    Resource,
+    ResourceFilterExpression,
+)
+from nucliadb_models.labels import LABEL_HIDDEN
+from nucliadb_models.metadata import ResourceProcessingStatus
+from nucliadb_models.search import (
+    SortField,
+    SortOptions,
+    SortOrder,
+)
+
+from .filter_expression import FacetFilterTypes, facet_from_filter
+
+
+async def parse_catalog(kbid: str, item: search_models.CatalogRequest) -> CatalogQuery:
+    has_old_filters = (
+        item.filters
+        or item.range_creation_start is not None
+        or item.range_creation_end is not None
+        or item.range_modification_start is not None
+        or item.range_modification_end is not None
+        or item.with_status is not None
+    )
+    if item.filter_expression is not None and has_old_filters:
+        raise InvalidQueryError("filter_expression", "Cannot mix old filters with filter_expression")
+
+    if has_old_filters:
+        catalog_expr = parse_old_filters(item)
+    elif item.filter_expression:
+        catalog_expr = await parse_filter_expression(item.filter_expression.resource, kbid)
+    else:
+        catalog_expr = None
+
+    if item.hidden is not None:
+        if item.hidden:
+            hidden_filter = CatalogExpression(facet=LABEL_HIDDEN)
+        else:
+            hidden_filter = CatalogExpression(bool_not=CatalogExpression(facet=LABEL_HIDDEN))
+
+        if catalog_expr:
+            catalog_expr = CatalogExpression(bool_and=[catalog_expr, hidden_filter])
+        else:
+            catalog_expr = hidden_filter
+
+    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=catalog_expr,
+        sort=sort,
+        faceted=item.faceted,
+        page_number=item.page_number,
+        page_size=item.page_size,
+    )
+
+
+def parse_old_filters(item: search_models.CatalogRequest) -> CatalogExpression:
+    expressions = []
+
+    for fltr in item.filters or []:
+        if isinstance(fltr, str):
+            expressions.append(CatalogExpression(facet=translate_label(fltr)))
+        elif fltr.all:
+            filters = [CatalogExpression(facet=translate_label(f)) for f in fltr.all]
+            expressions.append(CatalogExpression(bool_and=filters))
+        elif fltr.any:
+            filters = [CatalogExpression(facet=translate_label(f)) for f in fltr.any]
+            expressions.append(CatalogExpression(bool_or=filters))
+        elif fltr.none:
+            filters = [CatalogExpression(facet=translate_label(f)) for f in fltr.none]
+            expressions.append(CatalogExpression(bool_not=CatalogExpression(bool_or=filters)))
+        elif fltr.not_all:
+            filters = [CatalogExpression(facet=translate_label(f)) for f in fltr.not_all]
+            expressions.append(CatalogExpression(bool_not=CatalogExpression(bool_and=filters)))
+
+    if item.range_creation_start or item.range_creation_end:
+        expressions.append(
+            CatalogExpression(
+                date=CatalogExpression.Date(
+                    field="created_at",
+                    since=item.range_creation_start,
+                    until=item.range_creation_end,
+                )
+            )
+        )
+
+    if item.range_modification_start or item.range_modification_end:
+        expressions.append(
+            CatalogExpression(
+                date=CatalogExpression.Date(
+                    field="modified_at",
+                    since=item.range_modification_start,
+                    until=item.range_modification_end,
+                )
+            )
+        )
+
+    if item.with_status:
+        if item.with_status == ResourceProcessingStatus.PROCESSED:
+            expressions.append(
+                CatalogExpression(
+                    bool_or=[
+                        CatalogExpression(facet="/n/s/PROCESSED"),
+                        CatalogExpression(facet="/n/s/ERROR"),
+                    ]
+                )
+            )
+        else:
+            expressions.append(CatalogExpression(facet="/n/s/PENDING"))
+
+    return CatalogExpression(bool_and=expressions)
+
+
+async def parse_filter_expression(expr: ResourceFilterExpression, kbid: str) -> CatalogExpression:
+    cat = CatalogExpression()
+    if isinstance(expr, And):
+        cat.bool_and = []
+        for op in expr.operands:
+            cat.bool_and.append(await parse_filter_expression(op, kbid))
+    elif isinstance(expr, Or):
+        cat.bool_or = []
+        for op in expr.operands:
+            cat.bool_or.append(await parse_filter_expression(op, kbid))
+    elif isinstance(expr, Not):
+        cat.bool_not = await parse_filter_expression(expr.operand, kbid)
+    elif isinstance(expr, Resource):
+        if expr.id:
+            cat.resource_id = expr.id
+        else:
+            rid = await datamanagers.atomic.resources.get_resource_uuid_from_slug(
+                kbid=kbid, slug=expr.slug
+            )
+            if rid is None:
+                raise InvalidQueryError("slug", f"Cannot find slug {expr.slug}")
+            cat.resource_id = rid
+    elif isinstance(expr, DateCreated):
+        cat.date = CatalogExpression.Date(field="created_at", since=expr.since, until=expr.until)
+    elif isinstance(expr, DateModified):
+        cat.date = CatalogExpression.Date(field="modified_at", since=expr.since, until=expr.until)
+    elif isinstance(expr, FacetFilterTypes):
+        cat.facet = facet_from_filter(expr)
+    else:
+        # 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 cat

nucliadb/search/search/query_parser/filter_expression.py

@@ -23,7 +23,7 @@ from typing import Union
 from nucliadb.common import datamanagers
 from nucliadb.common.ids import FIELD_TYPE_NAME_TO_STR
 from nucliadb.search.search.exceptions import InvalidQueryError
-from nucliadb_models.filter import (
+from nucliadb_models.filters import (
     And,
     DateCreated,
     DateModified,
@@ -38,15 +38,52 @@ from nucliadb_models.filter import (
     Language,
     Not,
     Or,
+    OriginCollaborator,
     OriginMetadata,
     OriginPath,
+    OriginSource,
     OriginTag,
     ParagraphFilterExpression,
     Resource,
     ResourceMimetype,
+    Status,
 )
 from nucliadb_protos.nodereader_pb2 import FilterExpression as PBFilterExpression
 
+# Filters that end up as a facet
+FacetFilter = Union[
+    OriginTag,
+    Label,
+    ResourceMimetype,
+    FieldMimetype,
+    Entity,
+    Language,
+    OriginMetadata,
+    OriginPath,
+    Generated,
+    Kind,
+    OriginCollaborator,
+    OriginSource,
+    Status,
+]
+# In Python 3.9 we cannot do isinstance against an union
+# Once we support only 3.10+, we can remove this
+FacetFilterTypes = (
+    OriginTag,
+    Label,
+    ResourceMimetype,
+    FieldMimetype,
+    Entity,
+    Language,
+    OriginMetadata,
+    OriginPath,
+    Generated,
+    Kind,
+    OriginCollaborator,
+    OriginSource,
+    Status,
+)
+
 
 async def parse_expression(
     expr: Union[FieldFilterExpression, ParagraphFilterExpression],
@@ -90,47 +127,64 @@ async def parse_expression(
             f.date.since.FromDatetime(expr.since)
         if expr.until:
             f.date.until.FromDatetime(expr.until)
-    elif isinstance(expr, OriginTag):
-        f.facet.facet = f"/t/{expr.tag}"
+    elif isinstance(expr, FacetFilterTypes):
+        f.facet.facet = facet_from_filter(expr)
+    else:
+        # 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 f
+
+
+def facet_from_filter(expr: FacetFilter) -> str:
+    if isinstance(expr, OriginTag):
+        facet = f"/t/{expr.tag}"
     elif isinstance(expr, Label):
-        f.facet.facet = f"/l/{expr.labelset}"
+        facet = f"/l/{expr.labelset}"
         if expr.label:
-            f.facet.facet += f"/{expr.label}"
+            facet += f"/{expr.label}"
     elif isinstance(expr, ResourceMimetype):
-        f.facet.facet = f"/n/i/{expr.type}"
+        facet = f"/n/i/{expr.type}"
         if expr.subtype:
-            f.facet.facet += f"/{expr.subtype}"
+            facet += f"/{expr.subtype}"
     elif isinstance(expr, FieldMimetype):
-        f.facet.facet = f"/mt/{expr.type}"
+        facet = f"/mt/{expr.type}"
         if expr.subtype:
-            f.facet.facet += f"/{expr.subtype}"
+            facet += f"/{expr.subtype}"
     elif isinstance(expr, Entity):
-        f.facet.facet = f"/e/{expr.subtype}"
+        facet = f"/e/{expr.subtype}"
         if expr.value:
-            f.facet.facet += f"/{expr.value}"
+            facet += f"/{expr.value}"
     elif isinstance(expr, Language):
         if expr.only_primary:
-            f.facet.facet = f"/s/p/{expr.language}"
+            facet = f"/s/p/{expr.language}"
         else:
-            f.facet.facet = f"/s/s/{expr.language}"
+            facet = f"/s/s/{expr.language}"
     elif isinstance(expr, OriginMetadata):
-        f.facet.facet = f"/m/{expr.field}"
+        facet = f"/m/{expr.field}"
         if expr.value:
-            f.facet.facet += f"/{expr.value}"
+            facet += f"/{expr.value}"
     elif isinstance(expr, OriginPath):
-        f.facet.facet = f"/p/{expr.prefix}"
+        facet = f"/p/{expr.prefix}"
     elif isinstance(expr, Generated):
-        f.facet.facet = "/g/da"
+        facet = "/g/da"
         if expr.da_task:
-            f.facet.facet += f"/{expr.da_task}"
+            facet += f"/{expr.da_task}"
     elif isinstance(expr, Kind):
-        f.facet.facet = f"/k/{expr.kind.lower()}"
+        facet = f"/k/{expr.kind.lower()}"
+    elif isinstance(expr, OriginCollaborator):
+        facet = f"/u/o/{expr.collaborator}"
+    elif isinstance(expr, OriginSource):
+        facet = f"/u/s/{expr.id}"
+    elif isinstance(expr, Status):
+        facet = f"/n/s/{expr.status.value}"
     else:
         # 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 f
+    return facet
 
 
 def add_and_expression(dest: PBFilterExpression, add: PBFilterExpression):

nucliadb/search/search/query_parser/models.py

@@ -20,7 +20,7 @@
 
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Optional
+from typing import Literal, Optional, Union
 
 from pydantic import (
     BaseModel,
@@ -77,21 +77,26 @@ class UnitRetrieval:
 
 
 ### Catalog
+@dataclass
+class CatalogExpression:
+    @dataclass
+    class Date:
+        field: Union[Literal["created_at"], Literal["modified_at"]]
+        since: Optional[datetime]
+        until: Optional[datetime]
 
-
-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
+    bool_and: Optional[list["CatalogExpression"]] = None
+    bool_or: Optional[list["CatalogExpression"]] = None
+    bool_not: Optional["CatalogExpression"] = None
+    date: Optional[Date] = None
+    facet: Optional[str] = None
+    resource_id: Optional[str] = None
 
 
 class CatalogQuery(BaseModel):
     kbid: str
     query: str
-    filters: CatalogFilters
+    filters: Optional[CatalogExpression]
     sort: search_models.SortOptions
     faceted: list[str]
     page_size: int

nucliadb/search/search/query_parser/parser.py

@@ -18,19 +18,11 @@
 # 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 InternalParserError
 from nucliadb.search.search.query_parser.models import (
-    CatalogFilters,
-    CatalogQuery,
-    DateTimeFilter,
     NoopReranker,
     PredictReranker,
     RankFusion,
@@ -39,13 +31,8 @@ from nucliadb.search.search.query_parser.models import (
     UnitRetrieval,
 )
 from nucliadb_models import search as search_models
-from nucliadb_models.labels import LABEL_HIDDEN
 from nucliadb_models.search import (
-    Filter,
     FindRequest,
-    SortField,
-    SortOptions,
-    SortOrder,
 )
 
 
@@ -138,47 +125,3 @@ class _FindParser:
             raise InternalParserError(f"Unknown reranker {self.item.reranker}")
 
         return reranking
-
-
-def parse_catalog(kbid: str, item: search_models.CatalogRequest) -> CatalogQuery:
-    filters = item.filters
-
-    if item.hidden is not None:
-        if item.hidden:
-            filters.append(Filter(all=[LABEL_HIDDEN]))  # type: ignore
-        else:
-            filters.append(Filter(none=[LABEL_HIDDEN]))  # type: ignore
-
-    label_filters: dict[str, Any] = convert_to_node_filters(item.filters)
-    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.3.0.post3417.dist-info → nucliadb-6.3.0.post3421.dist-info}/METADATA

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

{nucliadb-6.3.0.post3417.dist-info → nucliadb-6.3.0.post3421.dist-info}/RECORD

@@ -192,20 +192,20 @@ nucliadb/search/utilities.py,sha256=9SsRDw0rJVXVoLBfF7rBb6q080h-thZc7u8uRcTiBeY,
 nucliadb/search/api/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/search/api/v1/__init__.py,sha256=8w6VhZ5rbzX1xLSXr336d2IE-O0dQiv-ba6UYdRKnHA,1325
 nucliadb/search/api/v1/ask.py,sha256=F2dR3-swb3Xz8MfZPYL3G65KY2R_mgef4YVBbu8kLi4,4352
-nucliadb/search/api/v1/catalog.py,sha256=TF19WN-qgZZLkqBwVH5xNsMxYTrmdEflPvy7qft_4lE,7010
+nucliadb/search/api/v1/catalog.py,sha256=LIoLknBAXIRwrJA3TCPoVIoYZZx41R1eMP7yR7x_f_Y,7579
 nucliadb/search/api/v1/feedback.py,sha256=kNLc4dHz2SXHzV0PwC1WiRAwY88fDptPcP-kO0q-FrQ,2620
-nucliadb/search/api/v1/find.py,sha256=2_YX0p6Y8dYVYy99OB0cgPlre13P_JfWmE07MnbVwlE,9627
+nucliadb/search/api/v1/find.py,sha256=l2dRg0eYngq52vyn9_z9iK7bdO7ufHQDnJWBZgMVrqY,9628
 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=DLXxh2FRXmLnZIIXaSLT7XaNoY2GZJTkpcduLTDyVW4,14023
-nucliadb/search/api/v1/suggest.py,sha256=urnA8rXLTcT2-Yulw2_43Ow8cAPWQEe5bxgDI9gNNZM,6505
+nucliadb/search/api/v1/search.py,sha256=tv9WHdoXKcU0HQYjajh2PoG-IjlFxPOl2hyQkug2kco,14024
+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
 nucliadb/search/api/v1/resource/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/search/api/v1/resource/ask.py,sha256=nsVzBSanSSlf0Ody6LSTjdEy75Vg283_YhbkAtWEjh8,3637
 nucliadb/search/api/v1/resource/ingestion_agents.py,sha256=fqqRCd8Wc9GciS5P98lcnihvTKStsZYYtOU-T1bc-6E,4771
-nucliadb/search/api/v1/resource/search.py,sha256=-GY84XiiGd2vyJtunWvZMdBhZU0O0giO-ISo-HMntBo,5227
+nucliadb/search/api/v1/resource/search.py,sha256=s_si6iilqhmopEQ5GG5c7C_4QV3X8QneQyS5zP0d22I,5228
 nucliadb/search/api/v1/resource/utils.py,sha256=-NjZqAQtFEXKpIh8ui5S26ItnJ5rzmmG0BHxGSS9QPw,1141
 nucliadb/search/requesters/__init__.py,sha256=itSI7dtTwFP55YMX4iK7JzdMHS5CQVUiB1XzQu4UBh8,833
 nucliadb/search/requesters/utils.py,sha256=qL81UVPNgBftUMLpcxIYVr7ILsMqpKCo-9SY2EvAaXw,6681
@@ -223,9 +223,9 @@ nucliadb/search/search/ingestion_agents.py,sha256=NeJr4EEX-bvFFMGvXOOwLv8uU7NuQ-
 nucliadb/search/search/merge.py,sha256=i_PTBFRqC5iTTziOMEltxLIlmokIou5hjjgR4BnoLBE,22635
 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=hNZJtbke0kFz9ygz70gMMJz9NxhRPznefCad83yQPd4,8887
+nucliadb/search/search/pgcatalog.py,sha256=V1NYLEUSXHpWmgcPIo1HS2riK_HDXSi-uykJjSoOOrE,9033
 nucliadb/search/search/predict_proxy.py,sha256=IFI3v_ODz2_UU1XZnyaD391fE7-2C0npSmj_HmDvzS4,3123
-nucliadb/search/search/query.py,sha256=j7NdAXQXSytWvf_tyqpG-Fz4AhVGI-Y5i7NPm3s7-PI,29980
+nucliadb/search/search/query.py,sha256=S6kvvTNIgOaqsPEisasgbcfsI7ax5E1G5RJwp7-a9jA,29981
 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
@@ -236,14 +236,15 @@ nucliadb/search/search/chat/ask.py,sha256=HPHM97s1dxbHvugoWZj6aP8vL4gzHjjtwoDvzU
 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=kMhtUOuVBkWbOaZnpzAUi32oRc5QnXKmlo2LFoozKWc,16382
+nucliadb/search/search/chat/query.py,sha256=2QhVzvX12zLHOpVZ5MlBflqAauyCBl6dojhRGdm_6qU,16388
 nucliadb/search/search/query_parser/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
+nucliadb/search/search/query_parser/catalog.py,sha256=EX6nDKH2qpMuuc7Ff0R_Ad78R4hj0JUDZp0ifUe1rrY,6963
 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/filter_expression.py,sha256=wdqqQzdMe5nMS4jZh0HT21ppSd5ur50jyZRjzjGI7o4,5123
-nucliadb/search/search/query_parser/models.py,sha256=2iWuTcH24RDF8xokgXr0j5qbMoURQ1TFyqJIYs16LqU,2283
+nucliadb/search/search/query_parser/filter_expression.py,sha256=jtQ3P0Hk7fyMgvf30wD1Ly7H-irPKDTr8DZ6yvI-brk,6211
+nucliadb/search/search/query_parser/models.py,sha256=VHDuyJlU2OLZN1usrQX53TZbPmWhzMeVYY0BiYNFzak,2464
 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/search/search/query_parser/parser.py,sha256=9TwkSNna3s-lCQIqBoSJzm6YbXdu8VIHJUan8M4ysfE,4667
 nucliadb/standalone/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/standalone/api_router.py,sha256=4-g-eEq27nL6vKCLRCoV0Pxf-L273N-eHeEX2vI9qgg,6215
 nucliadb/standalone/app.py,sha256=mAApNK_iVsQgJyd-mtwCeZq5csSimwnXmlQGH9a70pE,5586
@@ -339,8 +340,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.0.post3417.dist-info/METADATA,sha256=Nya_zwsp_AAX_HD3Qf6w7Hwd5UpeppIBUeCi9qqCnro,4291
-nucliadb-6.3.0.post3417.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
-nucliadb-6.3.0.post3417.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
-nucliadb-6.3.0.post3417.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
-nucliadb-6.3.0.post3417.dist-info/RECORD,,
+nucliadb-6.3.0.post3421.dist-info/METADATA,sha256=itnJYmnmoig4wWI-tFmvUkLB4De50-t-gnRIwk83Cns,4291
+nucliadb-6.3.0.post3421.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+nucliadb-6.3.0.post3421.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
+nucliadb-6.3.0.post3421.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
+nucliadb-6.3.0.post3421.dist-info/RECORD,,