nucliadb 6.3.4.post3817__py3-none-any.whl → 6.3.4.post3823__py3-none-any.whl

nucliadb/ingest/orm/entities.py

@@ -36,7 +36,7 @@ from nucliadb.common.datamanagers.entities import (
 from nucliadb.common.maindb.driver import Transaction
 from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
 from nucliadb.ingest.settings import settings
-from nucliadb.search.search.shards import query_shard
+from nucliadb.search.search.shards import graph_search_shard, query_shard
 from nucliadb_protos.knowledgebox_pb2 import (
     DeletedEntitiesGroups,
     EntitiesGroup,
@@ -45,9 +45,8 @@ from nucliadb_protos.knowledgebox_pb2 import (
 )
 from nucliadb_protos.nodereader_pb2 import (
     Faceted,
-    RelationNodeFilter,
-    RelationPrefixSearchRequest,
-    RelationSearchResponse,
+    GraphSearchRequest,
+    GraphSearchResponse,
     SearchRequest,
     SearchResponse,
 )
@@ -203,18 +202,16 @@ class EntitiesManager:
     async def get_indexed_entities_group(self, group: str) -> Optional[EntitiesGroup]:
         shard_manager = get_shard_manager()
 
-        async def do_entities_search(node: AbstractIndexNode, shard_id: str) -> RelationSearchResponse:
-            request = SearchRequest(
-                shard=shard_id,
-                relation_prefix=RelationPrefixSearchRequest(
-                    prefix="",
-                    node_filters=[
-                        RelationNodeFilter(node_type=RelationNode.NodeType.ENTITY, node_subtype=group)
-                    ],
-                ),
-            )
-            response = await query_shard(node, shard_id, request)
-            return response.relation
+        async def do_entities_search(node: AbstractIndexNode, shard_id: str) -> GraphSearchResponse:
+            request = GraphSearchRequest()
+            # XXX: this is a wild guess. Are those enough or too many?
+            request.top_k = 500
+            request.kind = GraphSearchRequest.QueryKind.NODES
+            request.query.path.path.source.node_type = RelationNode.NodeType.ENTITY
+            request.query.path.path.source.node_subtype = group
+            request.query.path.path.undirected = True
+            response = await graph_search_shard(node, shard_id, request)
+            return response
 
         results = await shard_manager.apply_for_all_shards(
             self.kbid,
@@ -224,7 +221,7 @@ class EntitiesManager:
 
         entities = {}
         for result in results:
-            entities.update({node.value: Entity(value=node.value) for node in result.prefix.nodes})
+            entities.update({node.value: Entity(value=node.value) for node in result.nodes})
 
         if not entities:
             return None

nucliadb/search/search/graph_strategy.py

@@ -44,7 +44,6 @@ from nucliadb.search.search.find_merge import (
     hydrate_and_rerank,
 )
 from nucliadb.search.search.hydrator import ResourceHydrationOptions, TextBlockHydrationOptions
-from nucliadb.search.search.merge import merge_relation_prefix_results
 from nucliadb.search.search.metrics import RAGMetrics
 from nucliadb.search.search.rerankers import Reranker, RerankingOptions
 from nucliadb.search.utilities import get_predict
@@ -65,6 +64,7 @@ from nucliadb_models.search import (
     NucliaDBClientType,
     QueryEntityDetection,
     RelatedEntities,
+    RelatedEntity,
     RelationDirection,
     RelationRanking,
     Relations,
@@ -443,26 +443,35 @@ async def fuzzy_search_entities(
 ) -> Optional[RelatedEntities]:
     """Fuzzy find entities in KB given a query using the same methodology as /suggest, but split by words."""
 
-    request = nodereader_pb2.SearchRequest()
-    request.relation_prefix.query = query
+    # Build an OR for each word in the query matching with fuzzy any word in any
+    # node in any position. I.e., for the query "Rose Hamiltn", it'll match
+    # "Rosa Parks" and "Margaret Hamilton"
+    request = nodereader_pb2.GraphSearchRequest()
+    # XXX Are those enough results? Too many?
+    request.top_k = 50
+    request.kind = nodereader_pb2.GraphSearchRequest.QueryKind.NODES
+    for word in query.split():
+        subquery = nodereader_pb2.GraphQuery.PathQuery()
+        subquery.path.source.value = word
+        subquery.path.source.fuzzy.kind = nodereader_pb2.GraphQuery.Node.MatchLocation.WORDS
+        subquery.path.source.fuzzy.distance = 1
+        subquery.path.undirected = True
+        request.query.path.bool_or.operands.append(subquery)
 
-    results: list[nodereader_pb2.SearchResponse]
     try:
-        (
-            results,
-            _,
-            _,
-        ) = await node_query(
-            kbid,
-            Method.SEARCH,
-            request,
-        )
-        return merge_relation_prefix_results(results)
-    except Exception as e:
-        capture_exception(e)
+        results, _, _ = await node_query(kbid, Method.GRAPH, request)
+    except Exception as exc:
+        capture_exception(exc)
         logger.exception("Error in finding entities in query for graph strategy")
         return None
 
+    # merge shard results while deduplicating repeated entities across shards
+    unique_entities: set[RelatedEntity] = set()
+    for response in results:
+        unique_entities.update((RelatedEntity(family=e.subtype, value=e.value) for e in response.nodes))
+
+    return RelatedEntities(entities=list(unique_entities), total=len(unique_entities))
+
 
 async def rank_relations_reranker(
     relations: Relations,

nucliadb/search/search/merge.py

@@ -632,19 +632,6 @@ async def merge_suggest_entities_results(
     return RelatedEntities(entities=list(unique_entities), total=len(unique_entities))
 
 
-def merge_relation_prefix_results(
-    responses: list[SearchResponse],
-) -> RelatedEntities:
-    unique_entities: Set[RelatedEntity] = set()
-    for response in responses:
-        response_entities = (
-            RelatedEntity(family=e.subtype, value=e.value) for e in response.relation.prefix.nodes
-        )
-        unique_entities.update(response_entities)
-
-    return RelatedEntities(entities=list(unique_entities), total=len(unique_entities))
-
-
 async def merge_suggest_results(
     suggest_responses: list[SuggestResponse],
     kbid: str,

nucliadb/search/search/query_parser/fetcher.py

@@ -17,6 +17,7 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
+import asyncio
 from typing import Optional, TypeVar, Union
 
 from async_lru import alru_cache
@@ -53,12 +54,9 @@ def is_cached(field: Union[T, NotCached]) -> TypeIs[T]:
 
 class FetcherCache:
     predict_query_info: Union[Optional[QueryInfo], NotCached] = not_cached
-    predict_detected_entities: Union[list[utils_pb2.RelationNode], NotCached] = not_cached
 
     # semantic search
-    query_vector: Union[Optional[list[float]], NotCached] = not_cached
     vectorset: Union[str, NotCached] = not_cached
-    matryoshka_dimension: Union[Optional[int], NotCached] = not_cached
 
     labels: Union[knowledgebox_pb2.Labels, NotCached] = not_cached
 
@@ -97,103 +95,80 @@ class Fetcher:
         self.query = query
         self.user_vector = user_vector
         self.user_vectorset = vectorset
+        self.user_vectorset_validated = False
         self.rephrase = rephrase
         self.rephrase_prompt = rephrase_prompt
         self.generative_model = generative_model
 
         self.cache = FetcherCache()
-        self._validated = False
-
-    # Validation
-
-    async def initial_validate(self):
-        """Runs a validation on the input parameters. It can raise errors if
-        there's some wrong parameter.
-
-        This function should be always called if validated input for fetching is
-        desired
-        """
-        if self._validated:
-            return
-
-        self._validated = True
-
-    async def _validate_vectorset(self):
-        if self.user_vectorset is not None:
-            await validate_vectorset(self.kbid, self.user_vectorset)
+        self.locks: dict[str, asyncio.Lock] = {}
 
     # Semantic search
 
     async def get_matryoshka_dimension(self) -> Optional[int]:
-        if is_cached(self.cache.matryoshka_dimension):
-            return self.cache.matryoshka_dimension
-
         vectorset = await self.get_vectorset()
-        matryoshka_dimension = await get_matryoshka_dimension_cached(self.kbid, vectorset)
-        self.cache.matryoshka_dimension = matryoshka_dimension
-        return matryoshka_dimension
+        return await get_matryoshka_dimension_cached(self.kbid, vectorset)
 
     async def _get_user_vectorset(self) -> Optional[str]:
         """Returns the user's requested vectorset and validates if it does exist
         in the KB.
 
         """
-        vectorset = self.user_vectorset
-        if not self._validated:
-            await self._validate_vectorset()
-        return vectorset
+        async with self.locks.setdefault("user_vectorset", asyncio.Lock()):
+            if not self.user_vectorset_validated:
+                if self.user_vectorset is not None:
+                    await validate_vectorset(self.kbid, self.user_vectorset)
+            self.user_vectorset_validated = True
+            return self.user_vectorset
 
     async def get_vectorset(self) -> str:
         """Get the vectorset to be used in the search. If not specified, by the
         user, Predict API or the own uses KB will provide a default.
 
         """
+        async with self.locks.setdefault("vectorset", asyncio.Lock()):
+            if is_cached(self.cache.vectorset):
+                return self.cache.vectorset
 
-        if is_cached(self.cache.vectorset):
-            return self.cache.vectorset
-
-        if self.user_vectorset:
-            # user explicitly asked for a vectorset
-            self.cache.vectorset = self.user_vectorset
-            return self.user_vectorset
+            user_vectorset = await self._get_user_vectorset()
+            if user_vectorset:
+                # user explicitly asked for a vectorset
+                self.cache.vectorset = user_vectorset
+                return user_vectorset
 
-        # when it's not provided, we get the default from Predict API
-        query_info = await self._predict_query_endpoint()
-        if query_info is None:
-            vectorset = None
-        else:
-            if query_info.sentence is None:
-                logger.error(
-                    "Asking for a vectorset but /query didn't return one", extra={"kbid": self.kbid}
-                )
+            # when it's not provided, we get the default from Predict API
+            query_info = await self._predict_query_endpoint()
+            if query_info is None:
                 vectorset = None
             else:
-                # vectors field is enforced by the data model to have at least one key
-                for vectorset in query_info.sentence.vectors.keys():
-                    vectorset = vectorset
-                    break
-
-        if vectorset is None:
-            # in case predict don't answer which vectorset to use, fallback to
-            # the first vectorset of the KB
-            async with datamanagers.with_ro_transaction() as txn:
-                async for vectorset, _ in datamanagers.vectorsets.iter(txn, kbid=self.kbid):
-                    break
-            assert vectorset is not None, "All KBs must have at least one vectorset in maindb"
-
-        self.cache.vectorset = vectorset
-        return vectorset
+                if query_info.sentence is None:
+                    logger.error(
+                        "Asking for a vectorset but /query didn't return one", extra={"kbid": self.kbid}
+                    )
+                    vectorset = None
+                else:
+                    # vectors field is enforced by the data model to have at least one key
+                    for vectorset in query_info.sentence.vectors.keys():
+                        vectorset = vectorset
+                        break
+
+            if vectorset is None:
+                # in case predict don't answer which vectorset to use, fallback to
+                # the first vectorset of the KB
+                async with datamanagers.with_ro_transaction() as txn:
+                    async for vectorset, _ in datamanagers.vectorsets.iter(txn, kbid=self.kbid):
+                        break
+                assert vectorset is not None, "All KBs must have at least one vectorset in maindb"
+
+            self.cache.vectorset = vectorset
+            return vectorset
 
     async def get_query_vector(self) -> Optional[list[float]]:
-        if is_cached(self.cache.query_vector):
-            return self.cache.query_vector
-
         if self.user_vector is not None:
             query_vector = self.user_vector
         else:
             query_info = await self._predict_query_endpoint()
             if query_info is None or query_info.sentence is None:
-                self.cache.query_vector = None
                 return None
 
             vectorset = await self.get_vectorset()
@@ -206,7 +181,6 @@ class Fetcher:
                         "predict_vectorsets": ",".join(query_info.sentence.vectors.keys()),
                     },
                 )
-                self.cache.query_vector = None
                 return None
 
             query_vector = query_info.sentence.vectors[vectorset]
@@ -223,7 +197,6 @@ class Fetcher:
             # accordingly
             query_vector = query_vector[:matryoshka_dimension]
 
-        self.cache.query_vector = query_vector
         return query_vector
 
     async def get_rephrased_query(self) -> Optional[str]:
@@ -235,100 +208,98 @@ class Fetcher:
     # Labels
 
     async def get_classification_labels(self) -> knowledgebox_pb2.Labels:
-        if is_cached(self.cache.labels):
-            return self.cache.labels
+        async with self.locks.setdefault("classification_labels", asyncio.Lock()):
+            if is_cached(self.cache.labels):
+                return self.cache.labels
 
-        labels = await get_classification_labels(self.kbid)
-        self.cache.labels = labels
-        return labels
+            labels = await get_classification_labels(self.kbid)
+            self.cache.labels = labels
+            return labels
 
     # Entities
 
     async def get_entities_meta_cache(self) -> datamanagers.entities.EntitiesMetaCache:
-        if is_cached(self.cache.entities_meta_cache):
-            return self.cache.entities_meta_cache
+        async with self.locks.setdefault("entities_meta_cache", asyncio.Lock()):
+            if is_cached(self.cache.entities_meta_cache):
+                return self.cache.entities_meta_cache
 
-        entities_meta_cache = await get_entities_meta_cache(self.kbid)
-        self.cache.entities_meta_cache = entities_meta_cache
-        return entities_meta_cache
+            entities_meta_cache = await get_entities_meta_cache(self.kbid)
+            self.cache.entities_meta_cache = entities_meta_cache
+            return entities_meta_cache
 
     async def get_deleted_entity_groups(self) -> list[str]:
-        if is_cached(self.cache.deleted_entity_groups):
-            return self.cache.deleted_entity_groups
+        async with self.locks.setdefault("deleted_entity_groups", asyncio.Lock()):
+            if is_cached(self.cache.deleted_entity_groups):
+                return self.cache.deleted_entity_groups
 
-        deleted_entity_groups = await get_deleted_entity_groups(self.kbid)
-        self.cache.deleted_entity_groups = deleted_entity_groups
-        return deleted_entity_groups
+            deleted_entity_groups = await get_deleted_entity_groups(self.kbid)
+            self.cache.deleted_entity_groups = deleted_entity_groups
+            return deleted_entity_groups
 
     async def get_detected_entities(self) -> list[utils_pb2.RelationNode]:
-        if is_cached(self.cache.detected_entities):
-            return self.cache.detected_entities
-
-        # Optimization to avoid calling predict twice
-        if is_cached(self.cache.predict_query_info):
-            # /query supersets detect entities, so we already have them
-            query_info = self.cache.predict_query_info
-            if query_info is not None and query_info.entities is not None:
-                detected_entities = convert_relations(query_info.entities.model_dump())
+        async with self.locks.setdefault("detected_entities", asyncio.Lock()):
+            if is_cached(self.cache.detected_entities):
+                return self.cache.detected_entities
+
+            # Optimization to avoid calling predict twice
+            if is_cached(self.cache.predict_query_info):
+                # /query supersets detect entities, so we already have them
+                query_info = self.cache.predict_query_info
+                if query_info is not None and query_info.entities is not None:
+                    detected_entities = convert_relations(query_info.entities.model_dump())
+                else:
+                    detected_entities = []
             else:
-                detected_entities = []
-        else:
-            # No call to /query has been done, we'll use detect entities
-            # endpoint instead (as it's faster)
-            detected_entities = await self._predict_detect_entities()
+                # No call to /query has been done, we'll use detect entities
+                # endpoint instead (as it's faster)
+                detected_entities = await self._predict_detect_entities()
 
-        self.cache.detected_entities = detected_entities
-        return detected_entities
+            self.cache.detected_entities = detected_entities
+            return detected_entities
 
     # Synonyms
 
     async def get_synonyms(self) -> Optional[knowledgebox_pb2.Synonyms]:
-        if is_cached(self.cache.synonyms):
-            return self.cache.synonyms
+        async with self.locks.setdefault("synonyms", asyncio.Lock()):
+            if is_cached(self.cache.synonyms):
+                return self.cache.synonyms
 
-        synonyms = await get_kb_synonyms(self.kbid)
-        self.cache.synonyms = synonyms
-        return synonyms
+            synonyms = await get_kb_synonyms(self.kbid)
+            self.cache.synonyms = synonyms
+            return synonyms
 
     # Predict API
 
     async def _predict_query_endpoint(self) -> Optional[QueryInfo]:
-        if is_cached(self.cache.predict_query_info):
-            return self.cache.predict_query_info
-
-        # calling twice should be avoided as query endpoint is a superset of detect entities
-        if is_cached(self.cache.predict_detected_entities):
-            logger.warning("Fetcher is not being efficient enough and has called predict twice!")
-
-        # we can't call get_vectorset, as it would do a recirsive loop between
-        # functions, so we'll manually parse it
-        vectorset = await self._get_user_vectorset()
-        try:
-            query_info = await query_information(
-                self.kbid,
-                self.query,
-                vectorset,
-                self.generative_model,
-                self.rephrase,
-                self.rephrase_prompt,
-            )
-        except (SendToPredictError, TimeoutError):
-            query_info = None
+        async with self.locks.setdefault("predict_query_endpoint", asyncio.Lock()):
+            if is_cached(self.cache.predict_query_info):
+                return self.cache.predict_query_info
+
+            # we can't call get_vectorset, as it would do a recirsive loop between
+            # functions, so we'll manually parse it
+            vectorset = await self._get_user_vectorset()
+            try:
+                query_info = await query_information(
+                    self.kbid,
+                    self.query,
+                    vectorset,
+                    self.generative_model,
+                    self.rephrase,
+                    self.rephrase_prompt,
+                )
+            except (SendToPredictError, TimeoutError):
+                query_info = None
 
-        self.cache.predict_query_info = query_info
-        return query_info
+            self.cache.predict_query_info = query_info
+            return query_info
 
     async def _predict_detect_entities(self) -> list[utils_pb2.RelationNode]:
-        if is_cached(self.cache.predict_detected_entities):
-            return self.cache.predict_detected_entities
-
         try:
             detected_entities = await detect_entities(self.kbid, self.query)
         except (SendToPredictError, TimeoutError) as ex:
             logger.warning(f"Errors on Predict API detecting entities: {ex}", extra={"kbid": self.kbid})
             detected_entities = []
 
-        self.cache.predict_detected_entities = detected_entities
         return detected_entities
 
 
@@ -360,7 +331,7 @@ async def detect_entities(kbid: str, query: str) -> list[utils_pb2.RelationNode]
 
 
 @alru_cache(maxsize=None)
-async def get_matryoshka_dimension_cached(kbid: str, vectorset: Optional[str]) -> Optional[int]:
+async def get_matryoshka_dimension_cached(kbid: str, vectorset: str) -> Optional[int]:
     # This can be safely cached as the matryoshka dimension is not expected to change
     return await get_matryoshka_dimension(kbid, vectorset)
 

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

@@ -221,11 +221,12 @@ def _parse_relation_query(
 def _set_node_to_pb(node: graph_requests.GraphNode, pb: nodereader_pb2.GraphQuery.Node):
     if node.value is not None:
         pb.value = node.value
-        if node.match == graph_requests.NodeMatchKind.EXACT:
-            pb.match_kind = nodereader_pb2.GraphQuery.Node.MatchKind.DEPRECATED_EXACT
+        if node.match == graph_requests.NodeMatchKindName.EXACT:
+            pb.exact.kind = nodereader_pb2.GraphQuery.Node.MatchLocation.FULL
 
-        elif node.match == graph_requests.NodeMatchKind.FUZZY:
-            pb.match_kind = nodereader_pb2.GraphQuery.Node.MatchKind.DEPRECATED_FUZZY
+        elif node.match == graph_requests.NodeMatchKindName.FUZZY:
+            pb.fuzzy.kind = nodereader_pb2.GraphQuery.Node.MatchLocation.PREFIX
+            pb.fuzzy.distance = 1
 
         else:  # pragma: nocover
             # This is a trick so mypy generates an error if this branch can be reached,

{nucliadb-6.3.4.post3817.dist-info → nucliadb-6.3.4.post3823.dist-info}/METADATA

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

{nucliadb-6.3.4.post3817.dist-info → nucliadb-6.3.4.post3823.dist-info}/RECORD

@@ -141,7 +141,7 @@ nucliadb/ingest/fields/text.py,sha256=tFvSQJAe0W7ePpp2_WDfLiE2yglR1OTU0Zht9acvOF
 nucliadb/ingest/orm/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
 nucliadb/ingest/orm/brain.py,sha256=A8H1J7Bo95sNzDgYr0_UNoemQhWOFEFz9UlYfs6ug-8,29407
 nucliadb/ingest/orm/broker_message.py,sha256=XWaiZgDOz94NPOPT-hqbRr5ZkpVimUw6PjUJNftfoVw,7514
-nucliadb/ingest/orm/entities.py,sha256=3_n6lKhBy2GsdmNmkh0_mvxP8md20OZsbtTNEmfJ8Hg,14888
+nucliadb/ingest/orm/entities.py,sha256=a-aYuKBUQhxDKFtXOzTAkLlY_t2JiTfaptw2vt3AQDQ,14915
 nucliadb/ingest/orm/exceptions.py,sha256=k4Esv4NtL4TrGTcsQpwrSfDhPQpiYcRbB1SpYmBX5MY,1432
 nucliadb/ingest/orm/knowledgebox.py,sha256=Bfb4-MIQWlaJrQAUDbgs_iIsXCYjS7s5YiiGl_Jb4jo,23887
 nucliadb/ingest/orm/metrics.py,sha256=OkwMSPKLZcKba0ZTwtTiIxwBgaLMX5ydhGieKvi2y7E,1096
@@ -229,10 +229,10 @@ nucliadb/search/search/filters.py,sha256=1MkHlJjAQqoRCj7e5cEzK2HvBxGLE17I_omsjik
 nucliadb/search/search/find.py,sha256=pjc-i55j_p_F1H0La4qc9slZSl_gICoFzl3fy6FLYTM,10314
 nucliadb/search/search/find_merge.py,sha256=3FnzKFEnVemg6FO_6zveulbAU7klvsiPEBvLrpBBMg8,17450
 nucliadb/search/search/graph_merge.py,sha256=OiUNiXOWwrUVKqStuRcoUJwvDbDYamqIgiAy_FwPdMI,3405
-nucliadb/search/search/graph_strategy.py,sha256=gisL2GpbSIa_SucyOwEt7TWdqURyAQqxvD_-PkXQct8,32339
+nucliadb/search/search/graph_strategy.py,sha256=SPJdDHQcTFsNb1IEWdWzklC5j1Vv9igibo0dYQAgcy0,33113
 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=bPO51Kc3Ec69UuCbF5ulokd02gWZhp7zlJSuMjGDo9Y,23141
+nucliadb/search/search/merge.py,sha256=fh5WnA_xnXp-Iiq5Cud9hIGole7_0OW2b3Oymk32D6Y,22689
 nucliadb/search/search/metrics.py,sha256=GGGtXHLhK79_ESV277xkBVjcaMURXHCxYG0EdGamUd8,2886
 nucliadb/search/search/paragraphs.py,sha256=pNAEiYqJGGUVcEf7xf-PFMVqz0PX4Qb-WNG-_zPGN2o,7799
 nucliadb/search/search/pgcatalog.py,sha256=s_J98fsX_RuFXwpejpkGqG-tD9ELuzz4YQ6U3ew5h2g,9313
@@ -251,14 +251,14 @@ nucliadb/search/search/chat/prompt.py,sha256=Jnja-Ss7skgnnDY8BymVfdeYsFPnIQFL8tE
 nucliadb/search/search/chat/query.py,sha256=0IoeW-JNaRBe2d9C3bXNfkYpzmsN_IIg3U4Vqb8eOEk,16485
 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=jhr__J0KmAzjdsTTadWQmD9qf6lZvqlKAfZdYjZH_UY,15742
+nucliadb/search/search/query_parser/fetcher.py,sha256=vrPgPnebWlrbx9fcelw7eHayEDptxnm9BP1F9LAEMws,15307
 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/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/catalog.py,sha256=XdBiTweGTQkj8m_V_i2xbwp7P5pPO8K1Tud692XKhMw,7149
 nucliadb/search/search/query_parser/parsers/find.py,sha256=q3wH_i0DGceeKckYEH3c5MqM5EvRiMCL7r-6nCAId9Q,4666
-nucliadb/search/search/query_parser/parsers/graph.py,sha256=43S8iSg4j9I_XD8zpW1VggDspQD-NMyS26B5Mw6Dktw,9358
+nucliadb/search/search/query_parser/parsers/graph.py,sha256=QJs-pybNXPsMSEkIHctb0Q0xQG-aArks8BtUxbJL5rU,9386
 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
@@ -354,8 +354,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.4.post3817.dist-info/METADATA,sha256=YJJR7no2TypIzteRiSkHcCRCO0O63H7eqF_ezQhgXSQ,4291
-nucliadb-6.3.4.post3817.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nucliadb-6.3.4.post3817.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
-nucliadb-6.3.4.post3817.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
-nucliadb-6.3.4.post3817.dist-info/RECORD,,
+nucliadb-6.3.4.post3823.dist-info/METADATA,sha256=id3yZ3Ww5cXYXQ1Y9VWVEhl_7cyP3m9RDTwGYxNH5Zc,4291
+nucliadb-6.3.4.post3823.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nucliadb-6.3.4.post3823.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
+nucliadb-6.3.4.post3823.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
+nucliadb-6.3.4.post3823.dist-info/RECORD,,