nidx-binding 6.3.7.post327__tar.gz → 6.3.7.post331__tar.gz

{nidx_binding-6.3.7.post327 → nidx_binding-6.3.7.post331}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.3.7.post327
+Version: 6.3.7.post331
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.3.7.post327 → nidx_binding-6.3.7.post331}/nidx_protos/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "nidx_protos"
-version = "6.3.7.post327"
+version = "6.3.7.post331"
 license = { text = "AGPL" }
 description = "Protobuf definitions for nucliadb/nidx"
 authors = [ { name = "Nuclia", email = "nucliadb@nuclia.com" }]

{nidx_binding-6.3.7.post327 → nidx_binding-6.3.7.post331}/nidx_relation/src/io_maps.rs

@@ -18,10 +18,10 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 //
 
+use nidx_protos::prost::*;
 use nidx_protos::relation::RelationType;
 use nidx_protos::relation_node::NodeType;
-use nidx_protos::{IndexRelation, prost::*};
-use nidx_protos::{Relation as ProtosRelation, RelationMetadata, RelationNode};
+use nidx_protos::{RelationMetadata, RelationNode};
 use tantivy::TantivyDocument;
 use tantivy::schema::Value;
 
@@ -98,16 +98,6 @@ pub fn target_to_relation_node(schema: &Schema, doc: &TantivyDocument) -> Relati
     }
 }
 
-pub fn doc_to_relation(schema: &Schema, doc: &TantivyDocument) -> ProtosRelation {
-    ProtosRelation {
-        metadata: decode_metadata(schema, doc),
-        relation: u64_to_relation_type::<i32>(schema.relationship(doc)),
-        relation_label: schema.relationship_label(doc).to_string(),
-        source: Some(source_to_relation_node(schema, doc)),
-        to: Some(target_to_relation_node(schema, doc)),
-    }
-}
-
 pub fn doc_to_resource_field_id(schema: &Schema, doc: &TantivyDocument) -> Option<String> {
     doc.get_first(schema.resource_field_id).map(|v| {
         let (rid, fid) = decode_field_id(v.as_bytes().unwrap());
@@ -121,14 +111,6 @@ pub fn doc_to_facets(schema: &Schema, doc: &TantivyDocument) -> Vec<String> {
         .collect()
 }
 
-pub fn doc_to_index_relation(schema: &Schema, doc: &TantivyDocument) -> IndexRelation {
-    IndexRelation {
-        relation: Some(doc_to_relation(schema, doc)),
-        resource_field_id: doc_to_resource_field_id(schema, doc),
-        facets: doc_to_facets(schema, doc),
-    }
-}
-
 pub fn doc_to_graph_relation(schema: &Schema, doc: &TantivyDocument) -> nidx_protos::graph_search_response::Relation {
     nidx_protos::graph_search_response::Relation {
         relation_type: u64_to_relation_type::<i32>(schema.relationship(doc)),

{nidx_binding-6.3.7.post327 → nidx_binding-6.3.7.post331}/nidx_relation/src/lib.rs

@@ -34,8 +34,7 @@ use nidx_protos::graph_query::node::NewMatchKind;
 use nidx_protos::graph_query::path_query;
 use nidx_protos::graph_search_request::QueryKind;
 use nidx_protos::{
-    GraphSearchRequest, GraphSearchResponse, RelationNode, RelationSearchRequest, RelationSearchResponse,
-    relation_node::NodeType, resource::ResourceStatus,
+    GraphSearchRequest, GraphSearchResponse, RelationNode, relation_node::NodeType, resource::ResourceStatus,
 };
 use nidx_tantivy::{
     TantivyIndexer, TantivyMeta, TantivySegmentMetadata,
@@ -208,11 +207,6 @@ impl RelationSearcher {
     }
 
     #[instrument(name = "relation::search", skip_all)]
-    pub fn search(&self, request: &RelationSearchRequest) -> anyhow::Result<RelationSearchResponse> {
-        self.reader.relation_search(request)
-    }
-
-    #[instrument(name = "relation::graph_search", skip_all)]
     pub fn graph_search(
         &self,
         request: &GraphSearchRequest,

{nidx_binding-6.3.7.post327 → nidx_binding-6.3.7.post331}/nidx_relation/src/reader.rs

@@ -21,29 +21,22 @@ use std::fmt::Debug;
 use std::path::Path;
 
 use nidx_protos::graph_search_request::QueryKind;
-use nidx_protos::{
-    EntitiesSubgraphResponse, GraphSearchRequest, GraphSearchResponse, RelationNode, RelationSearchRequest,
-    RelationSearchResponse,
-};
+use nidx_protos::{GraphSearchRequest, GraphSearchResponse, RelationNode};
 use nidx_types::prefilter::{FieldId, PrefilterResult};
 use tantivy::collector::TopDocs;
-use tantivy::query::{BooleanQuery, EmptyQuery, Occur, Query, TermSetQuery};
+use tantivy::query::{BooleanQuery, EmptyQuery, Query, TermSetQuery};
 use tantivy::schema::Field;
 use tantivy::{Index, IndexReader};
 use uuid::Uuid;
 
 use crate::graph_collector::{Selector, TopUniqueCollector};
-use crate::graph_query_parser::{
-    BoolGraphQuery, BoolNodeQuery, Expression, GraphQuery, GraphQueryParser, Node, NodeQuery,
-};
+use crate::graph_query_parser::{BoolGraphQuery, BoolNodeQuery, GraphQueryParser};
 use crate::schema::{Schema, decode_node, decode_relation, encode_field_id};
 use crate::top_unique_n::TopUniqueN;
 use crate::{RelationConfig, io_maps};
 
 pub const FUZZY_DISTANCE: u8 = 1;
 pub const NUMBER_OF_RESULTS_SUGGEST: usize = 20;
-// Hard limit until we have pagination in place
-const MAX_NUM_RELATIONS_RESULTS: usize = 500;
 
 pub struct RelationsReaderService {
     pub index: Index,
@@ -102,13 +95,6 @@ impl<'a, I: Iterator<Item = &'a FieldId>> Iterator for AddMetadataFieldIterator<
 }
 
 impl RelationsReaderService {
-    pub fn relation_search(&self, request: &RelationSearchRequest) -> anyhow::Result<RelationSearchResponse> {
-        Ok(RelationSearchResponse {
-            subgraph: self.entities_subgraph_search(request)?,
-            prefix: None,
-        })
-    }
-
     pub fn graph_search(
         &self,
         request: &GraphSearchRequest,
@@ -290,100 +276,6 @@ impl RelationsReaderService {
             schema: field_schema,
         })
     }
-
-    // TODO: remove unused method
-    fn entities_subgraph_search(
-        &self,
-        request: &RelationSearchRequest,
-    ) -> anyhow::Result<Option<EntitiesSubgraphResponse>> {
-        let Some(bfs_request) = request.subgraph.as_ref() else {
-            return Ok(None);
-        };
-
-        if bfs_request.depth() != 1 {
-            return Err(anyhow::anyhow!("Depth must be 1 right now"));
-        }
-
-        if bfs_request.entry_points.is_empty() {
-            return Ok(Some(EntitiesSubgraphResponse::default()));
-        }
-
-        let query_parser = GraphQueryParser::new(&self.schema);
-        let mut statements = vec![];
-
-        // Entry points are source or target nodes we want to search for. We want any undirected
-        // path containing any entry point
-        for entry_point in bfs_request.entry_points.iter() {
-            statements.push((
-                Occur::Should,
-                query_parser.parse(GraphQuery::NodeQuery(NodeQuery::Node(Expression::Value(Node {
-                    value: Some(entry_point.value.clone().into()),
-                    node_type: Some(entry_point.ntype()),
-                    node_subtype: Some(entry_point.subtype.clone()),
-                })))),
-            ));
-        }
-
-        // A query can specifiy nodes marked as deleted in the db (but not removed from the index).
-        // We want to exclude any path containing any of those nodes.
-        //
-        // The request groups values per subtype (to optimize request size) but, as we don't support
-        // OR at node value level, we'll split them.
-        for deleted_nodes in bfs_request.deleted_entities.iter() {
-            if deleted_nodes.node_values.is_empty() {
-                continue;
-            }
-            statements.push((
-                Occur::MustNot,
-                query_parser.parse(GraphQuery::NodeQuery(NodeQuery::Node(Expression::Or(
-                    deleted_nodes
-                        .node_values
-                        .iter()
-                        .map(|deleted_entity_value| Node {
-                            value: Some(deleted_entity_value.clone().into()),
-                            node_subtype: Some(deleted_nodes.node_subtype.clone()),
-                            ..Default::default()
-                        })
-                        .collect(),
-                )))),
-            ));
-        }
-
-        // Subtypes can also be marked as deleted in the db (but kept in the index). We also want to
-        // exclude any triplet containg a node with such subtypes
-        let excluded_subtypes: Vec<_> = bfs_request
-            .deleted_groups
-            .iter()
-            .map(|deleted_subtype| Node {
-                node_subtype: Some(deleted_subtype.clone()),
-                ..Default::default()
-            })
-            .collect();
-
-        if !excluded_subtypes.is_empty() {
-            statements.push((
-                Occur::MustNot,
-                query_parser.parse(GraphQuery::NodeQuery(NodeQuery::Node(Expression::Or(
-                    excluded_subtypes,
-                )))),
-            ))
-        }
-
-        let query: Box<dyn Query> = Box::new(BooleanQuery::new(statements));
-        let searcher = self.reader.searcher();
-
-        let topdocs = TopDocs::with_limit(MAX_NUM_RELATIONS_RESULTS);
-        let matching_docs = searcher.search(&query, &topdocs)?;
-        let mut response = EntitiesSubgraphResponse::default();
-
-        for (_, doc_addr) in matching_docs {
-            let source = searcher.doc(doc_addr)?;
-            let index_relation = io_maps::doc_to_index_relation(&self.schema, &source);
-            response.relations.push(index_relation);
-        }
-
-        Ok(Some(response))
-    }
 }
 
 #[derive(Debug)]

{nidx_binding-6.3.7.post327 → nidx_binding-6.3.7.post331}/pyproject.toml

@@ -13,7 +13,7 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
-version = "6.3.7.post327"
+version = "6.3.7.post331"
 
 [project.urls]
 Homepage = "https://nuclia.com"

{nidx_binding-6.3.7.post327 → nidx_binding-6.3.7.post331}/src/searcher/query_planner.rs

@@ -20,12 +20,8 @@
 
 use nidx_paragraph::ParagraphSearchRequest;
 use nidx_protos::filter_expression::Expr;
-use nidx_protos::graph_query::{self, PathQuery, path_query};
 use nidx_protos::graph_search_request::QueryKind;
-use nidx_protos::search_request::GraphSearch;
-use nidx_protos::{
-    EntitiesSubgraphRequest, FilterExpression, FilterOperator, GraphQuery, GraphSearchRequest, SearchRequest,
-};
+use nidx_protos::{FilterExpression, FilterOperator, GraphSearchRequest, SearchRequest};
 use nidx_text::DocumentSearchRequest;
 use nidx_text::prefilter::*;
 use nidx_types::prefilter::PrefilterResult;
@@ -70,7 +66,7 @@ pub struct QueryPlan {
 }
 
 pub fn build_query_plan(search_request: SearchRequest) -> anyhow::Result<QueryPlan> {
-    let graph_request = compute_relations_request(&search_request)?;
+    let graph_request = compute_graph_request(&search_request)?;
     let texts_request = compute_texts_request(&search_request);
     let vectors_request = compute_vectors_request(&search_request)?;
     let paragraphs_request = compute_paragraphs_request(&search_request)?;
@@ -177,22 +173,9 @@ fn compute_vectors_request(search_request: &SearchRequest) -> anyhow::Result<Opt
 }
 
 #[allow(deprecated)]
-fn compute_relations_request(search_request: &SearchRequest) -> anyhow::Result<Option<GraphSearchRequest>> {
-    let graph_search = match (
-        search_request.relation_subgraph.as_ref(),
-        search_request.graph_search.as_ref(),
-    ) {
-        (None, None) => return Ok(None),
-        (Some(_), Some(_)) => {
-            return Err(anyhow::anyhow!(
-                "Entities subgraph and graph search are mutually exclusive features"
-            ));
-        }
-        (Some(bfs_request), None) => {
-            // Bw/c: we'll convert the entities subgraph request into a graph request
-            convert_entities_subgraph_into_graph_search(bfs_request)
-        }
-        (None, Some(graph_search)) => graph_search.clone(),
+fn compute_graph_request(search_request: &SearchRequest) -> anyhow::Result<Option<GraphSearchRequest>> {
+    let Some(graph_search) = search_request.graph_search.clone() else {
+        return Ok(None);
     };
 
     Ok(Some(GraphSearchRequest {
@@ -205,126 +188,6 @@ fn compute_relations_request(search_request: &SearchRequest) -> anyhow::Result<O
     }))
 }
 
-fn convert_entities_subgraph_into_graph_search(bfs_request: &EntitiesSubgraphRequest) -> GraphSearch {
-    if bfs_request.entry_points.is_empty() {
-        return GraphSearch { query: None };
-    }
-
-    // Entry points are source or target nodes we want to search for. We want any undirected
-    // path containing any entry point
-    let entry_points_queries: Vec<PathQuery> = bfs_request
-        .entry_points
-        .iter()
-        .map(|entry_point| PathQuery {
-            query: Some(path_query::Query::Path(graph_query::Path {
-                source: Some(graph_query::Node {
-                    value: Some(entry_point.value.clone()),
-                    node_type: Some(entry_point.ntype),
-                    node_subtype: Some(entry_point.subtype.clone()),
-                    ..Default::default()
-                }),
-                undirected: true,
-                ..Default::default()
-            })),
-        })
-        .collect();
-
-    // A query can specifiy nodes marked as deleted in the db (but not removed from the index).
-    // We want to exclude any path containing any of those nodes.
-    //
-    // The request groups values per subtype (to optimize request size) but, as we don't support
-    // OR at node value level, we'll split them.
-    let deleted_nodes_queries: Vec<PathQuery> = bfs_request
-        .deleted_entities
-        .iter()
-        .flat_map(|deleted_nodes| {
-            if deleted_nodes.node_values.is_empty() {
-                return None;
-            }
-            let subtype = &deleted_nodes.node_subtype;
-
-            let subqueries = deleted_nodes
-                .node_values
-                .iter()
-                .map(|deleted_entity_value| PathQuery {
-                    query: Some(path_query::Query::Path(graph_query::Path {
-                        source: Some(graph_query::Node {
-                            value: Some(deleted_entity_value.clone()),
-                            node_subtype: Some(subtype.clone()),
-                            ..Default::default()
-                        }),
-                        undirected: true,
-                        ..Default::default()
-                    })),
-                })
-                .collect::<Vec<_>>();
-            Some(subqueries)
-        })
-        .flatten()
-        .collect();
-
-    // Subtypes can also be marked as deleted in the db (but kept in the index). We also
-    // want to exclude any triplet containg a node with such subtypes
-    let excluded_subtypes_queries: Vec<PathQuery> = bfs_request
-        .deleted_groups
-        .iter()
-        .map(|deleted_subtype| PathQuery {
-            query: Some(path_query::Query::Path(graph_query::Path {
-                source: Some(graph_query::Node {
-                    node_subtype: Some(deleted_subtype.clone()),
-                    ..Default::default()
-                }),
-                undirected: true,
-                ..Default::default()
-            })),
-        })
-        .collect::<Vec<_>>();
-
-    let mut subqueries = vec![];
-    if !entry_points_queries.is_empty() {
-        // match any entry point
-        subqueries.push(PathQuery {
-            query: Some(path_query::Query::BoolOr(graph_query::BoolQuery {
-                operands: entry_points_queries,
-            })),
-        });
-    }
-
-    if !deleted_nodes_queries.is_empty() {
-        // exclude deleted nodes
-        subqueries.push(PathQuery {
-            query: Some(path_query::Query::BoolNot(Box::new(PathQuery {
-                query: Some(path_query::Query::BoolOr(graph_query::BoolQuery {
-                    operands: deleted_nodes_queries,
-                })),
-            }))),
-        });
-    }
-
-    if !excluded_subtypes_queries.is_empty() {
-        // exclude specific subtypes
-        subqueries.push(PathQuery {
-            query: Some(path_query::Query::BoolNot(Box::new(PathQuery {
-                query: Some(path_query::Query::BoolOr(graph_query::BoolQuery {
-                    operands: excluded_subtypes_queries,
-                })),
-            }))),
-        });
-    }
-
-    let graph_query = GraphQuery {
-        path: Some(PathQuery {
-            query: Some(path_query::Query::BoolAnd(graph_query::BoolQuery {
-                operands: subqueries,
-            })),
-        }),
-    };
-
-    GraphSearch {
-        query: Some(graph_query),
-    }
-}
-
 pub fn filter_to_boolean_expression(filter: FilterExpression) -> anyhow::Result<BooleanExpression<String>> {
     match filter.expr.unwrap() {
         Expr::BoolAnd(and) => {

{nidx_binding-6.3.7.post327 → nidx_binding-6.3.7.post331}/src/searcher/shard_search.rs

@@ -21,10 +21,7 @@
 use std::sync::Arc;
 
 use nidx_paragraph::ParagraphSearcher;
-use nidx_protos::{
-    EntitiesSubgraphResponse, GraphSearchRequest, GraphSearchResponse, IndexRelation, Relation, RelationSearchResponse,
-    SearchRequest, SearchResponse,
-};
+use nidx_protos::{GraphSearchRequest, GraphSearchResponse, SearchRequest, SearchResponse};
 use nidx_relation::RelationSearcher;
 use nidx_text::{TextSearcher, prefilter::PreFilterRequest};
 use nidx_types::prefilter::PrefilterResult;
@@ -172,44 +169,11 @@ fn blocking_search(
         }
     });
 
-    let graph_response = rrelation.transpose()?;
-
-    // Bw/c: convert graph search into relation response
-    let relation_response = graph_response.clone().map(|graph_response| {
-        let relations = graph_response
-            .graph
-            .into_iter()
-            .map(|path| {
-                let source = graph_response.nodes[path.source as usize].clone();
-                let relation = graph_response.relations[path.relation as usize].clone();
-                let destination = graph_response.nodes[path.destination as usize].clone();
-
-                IndexRelation {
-                    relation: Some(Relation {
-                        source: Some(source),
-                        to: Some(destination),
-                        relation: relation.relation_type,
-                        relation_label: relation.label,
-                        metadata: path.metadata,
-                    }),
-                    resource_field_id: path.resource_field_id,
-                    facets: path.facets,
-                }
-            })
-            .collect();
-
-        RelationSearchResponse {
-            subgraph: Some(EntitiesSubgraphResponse { relations }),
-            ..Default::default()
-        }
-    });
-
     Ok(SearchResponse {
         document: rtext.transpose()?,
         paragraph: rparagraph.transpose()?,
         vector: rvector.transpose()?,
-        relation: relation_response,
-        graph: graph_response,
+        graph: rrelation.transpose()?,
     })
 }
 

{nidx_binding-6.3.7.post327 → nidx_binding-6.3.7.post331}/tests/test_date_range_search.rs

@@ -254,7 +254,7 @@ async fn test_date_range_search(pool: PgPool) -> Result<(), Box<dyn std::error::
     assert_eq!(result.document, None);
     assert_eq!(result.paragraph, None);
     assert_eq!(result.vector, None);
-    assert_eq!(result.relation, None);
+    assert_eq!(result.graph, None);
 
     // Multiple timestamps are parsed as AND conditions
     let mut request_second_batch = request.clone();
@@ -283,7 +283,7 @@ async fn test_date_range_search(pool: PgPool) -> Result<(), Box<dyn std::error::
     assert_eq!(result.document, None);
     assert_eq!(result.paragraph, None);
     assert_eq!(result.vector, None);
-    assert_eq!(result.relation, None);
+    assert_eq!(result.graph, None);
 
     Ok(())
 }