nidx-binding 6.3.4.post154__tar.gz → 6.3.4.post159__tar.gz

{nidx_binding-6.3.4.post154 → nidx_binding-6.3.4.post159}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.3.4.post154
+Version: 6.3.4.post159
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.3.4.post154 → nidx_binding-6.3.4.post159}/nidx_protos/pyproject.toml

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

{nidx_binding-6.3.4.post154 → nidx_binding-6.3.4.post159}/nidx_relation/src/graph_query_parser.rs

@@ -18,11 +18,12 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 //
 use anyhow::anyhow;
+use nidx_protos::graph_query::FacetFilter;
 use nidx_protos::relation::RelationType;
 use nidx_protos::relation_node::NodeType;
 use nidx_types::query_language::{BooleanExpression, BooleanOperation, Operator};
 use tantivy::query::{AllQuery, BooleanQuery, FuzzyTermQuery, Occur, Query, TermQuery};
-use tantivy::schema::{Field, IndexRecordOption};
+use tantivy::schema::{Facet, Field, IndexRecordOption};
 use tantivy::tokenizer::TokenizerManager;
 
 use crate::io_maps;
@@ -109,6 +110,8 @@ pub enum GraphQuery {
     RelationQuery(RelationQuery),
     // (:A)-[:R]->(:B)
     PathQuery(PathQuery),
+
+    Facet(String),
 }
 
 #[derive(Clone, Copy)]
@@ -117,7 +120,13 @@ enum NodePosition {
     Destination,
 }
 
-pub struct BoolNodeQuery(BooleanExpression<Node>);
+#[derive(Clone)]
+enum NodeExpression {
+    Node(Node),
+    Facet(String),
+}
+
+pub struct BoolNodeQuery(BooleanExpression<NodeExpression>);
 pub struct BoolGraphQuery(BooleanExpression<GraphQuery>);
 
 #[derive(Clone, Copy)]
@@ -172,9 +181,13 @@ impl<'a> GraphQueryParser<'a> {
         )
     }
 
-    fn inner_parse_bool_node(&self, query: BooleanExpression<Node>, position: NodePosition) -> Box<dyn Query> {
+    fn inner_parse_bool_node(
+        &self,
+        query: BooleanExpression<NodeExpression>,
+        position: NodePosition,
+    ) -> Box<dyn Query> {
         match query {
-            BooleanExpression::Literal(node) => match position {
+            BooleanExpression::Literal(NodeExpression::Node(node)) => match position {
                 NodePosition::Source => {
                     self.parse(GraphQuery::NodeQuery(NodeQuery::SourceNode(Expression::Value(node))))
                 }
@@ -182,6 +195,7 @@ impl<'a> GraphQueryParser<'a> {
                     Expression::Value(node),
                 ))),
             },
+            BooleanExpression::Literal(NodeExpression::Facet(facet)) => self.parse_facet(&facet),
             BooleanExpression::Not(subquery) => {
                 let subqueries = vec![
                     (Occur::Must, Box::new(AllQuery) as Box<dyn Query>),
@@ -210,6 +224,7 @@ impl<'a> GraphQueryParser<'a> {
             GraphQuery::NodeQuery(query) => self.parse_node_query(query),
             GraphQuery::RelationQuery(query) => self.parse_relation_query(query),
             GraphQuery::PathQuery(query) => self.parse_path_query(query),
+            GraphQuery::Facet(facet) => self.parse_facet(&facet),
         }
     }
 
@@ -245,6 +260,13 @@ impl<'a> GraphQueryParser<'a> {
         self.parse_path_query(equivalent_path_query)
     }
 
+    fn parse_facet(&self, facet: &str) -> Box<dyn Query> {
+        Box::new(TermQuery::new(
+            tantivy::Term::from_facet(self.schema.facets, &Facet::from_text(facet).expect("Invalid facet")),
+            IndexRecordOption::Basic,
+        ))
+    }
+
     fn parse_path_query(&self, query: PathQuery) -> Box<dyn Query> {
         match query {
             PathQuery::DirectedPath((source_expression, relation_expression, destination_expression)) => {
@@ -564,14 +586,12 @@ impl TryFrom<&nidx_protos::graph_query::PathQuery> for BoolNodeQuery {
 
                     let pb_node = path.source.as_ref().unwrap();
                     let node = Node::try_from(pb_node)?;
-                    BooleanExpression::Literal(node)
+                    BooleanExpression::Literal(NodeExpression::Node(node))
                 }
-
                 nidx_protos::graph_query::path_query::Query::BoolNot(bool_not) => {
                     let subquery = BoolNodeQuery::try_from(bool_not.as_ref())?.0;
                     BooleanExpression::Not(Box::new(subquery))
                 }
-
                 nidx_protos::graph_query::path_query::Query::BoolAnd(bool_and) => {
                     BooleanExpression::Operation(BooleanOperation {
                         operator: Operator::And,
@@ -582,7 +602,6 @@ impl TryFrom<&nidx_protos::graph_query::PathQuery> for BoolNodeQuery {
                             .collect::<anyhow::Result<Vec<_>>>()?,
                     })
                 }
-
                 nidx_protos::graph_query::path_query::Query::BoolOr(bool_or) => {
                     BooleanExpression::Operation(BooleanOperation {
                         operator: Operator::Or,
@@ -593,9 +612,12 @@ impl TryFrom<&nidx_protos::graph_query::PathQuery> for BoolNodeQuery {
                             .collect::<anyhow::Result<Vec<_>>>()?,
                     })
                 }
+                nidx_protos::graph_query::path_query::Query::Facet(FacetFilter { facet }) => {
+                    BooleanExpression::Literal(NodeExpression::Facet(facet.clone()))
+                }
             },
 
-            None => BooleanExpression::Literal(Node::default()),
+            None => BooleanExpression::Literal(NodeExpression::Node(Node::default())),
         };
 
         Ok(BoolNodeQuery(bool_expr))
@@ -638,12 +660,10 @@ impl TryFrom<&nidx_protos::graph_query::PathQuery> for BoolGraphQuery {
 
                     BooleanExpression::Literal(path_query)
                 }
-
                 nidx_protos::graph_query::path_query::Query::BoolNot(bool_not) => {
                     let subquery = BoolGraphQuery::try_from(bool_not.as_ref())?.0;
                     BooleanExpression::Not(Box::new(subquery))
                 }
-
                 nidx_protos::graph_query::path_query::Query::BoolAnd(bool_and) => {
                     BooleanExpression::Operation(BooleanOperation {
                         operator: Operator::And,
@@ -654,7 +674,6 @@ impl TryFrom<&nidx_protos::graph_query::PathQuery> for BoolGraphQuery {
                             .collect::<anyhow::Result<Vec<_>>>()?,
                     })
                 }
-
                 nidx_protos::graph_query::path_query::Query::BoolOr(bool_or) => {
                     BooleanExpression::Operation(BooleanOperation {
                         operator: Operator::Or,
@@ -665,6 +684,9 @@ impl TryFrom<&nidx_protos::graph_query::PathQuery> for BoolGraphQuery {
                             .collect::<anyhow::Result<Vec<_>>>()?,
                     })
                 }
+                nidx_protos::graph_query::path_query::Query::Facet(FacetFilter { facet }) => {
+                    BooleanExpression::Literal(GraphQuery::Facet(facet.clone()))
+                }
             },
 
             None => BooleanExpression::Literal(GraphQuery::PathQuery(PathQuery::UndirectedPath((

{nidx_binding-6.3.4.post154 → nidx_binding-6.3.4.post159}/nidx_relation/tests/test_graph_search.rs

@@ -23,10 +23,13 @@ use std::collections::HashMap;
 
 use nidx_protos::graph_query::node::MatchKind;
 use nidx_protos::graph_query::path_query::Query;
-use nidx_protos::graph_query::{BoolQuery, Node, Path, PathQuery, Relation};
+use nidx_protos::graph_query::{BoolQuery, FacetFilter, Node, Path, PathQuery, Relation};
 use nidx_protos::relation::RelationType;
 use nidx_protos::relation_node::NodeType;
-use nidx_protos::{GraphQuery, GraphSearchRequest, GraphSearchResponse, IndexRelations, Resource, ResourceId};
+use nidx_protos::{
+    GraphQuery, GraphSearchRequest, GraphSearchResponse, IndexRelation, IndexRelations, RelationNode, Resource,
+    ResourceId,
+};
 use nidx_relation::{RelationConfig, RelationIndexer, RelationSearcher};
 use nidx_tests::graph::friendly_parse;
 use nidx_types::prefilter::{FieldId, PrefilterResult};
@@ -569,6 +572,147 @@ fn test_prefilter() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_facet_filter() -> anyhow::Result<()> {
+    let dir = TempDir::new().unwrap();
+
+    // Create a graph with relations with different facets
+    let relations = vec![
+        IndexRelation {
+            relation: Some(nidx_protos::Relation {
+                source: Some(RelationNode {
+                    ntype: NodeType::Entity.into(),
+                    subtype: "PERSON".to_string(),
+                    value: "Peter Processor".to_string(),
+                }),
+                to: Some(RelationNode {
+                    ntype: NodeType::Entity.into(),
+                    subtype: "PERSON".to_string(),
+                    value: "Pedro Procesador".to_string(),
+                }),
+                relation: RelationType::Entity.into(),
+                relation_label: "SAME".to_string(),
+                metadata: None,
+            }),
+            facets: vec![],
+            ..Default::default()
+        },
+        IndexRelation {
+            relation: Some(nidx_protos::Relation {
+                source: Some(RelationNode {
+                    ntype: NodeType::Entity.into(),
+                    subtype: "PERSON".to_string(),
+                    value: "Ursula User".to_string(),
+                }),
+                to: Some(RelationNode {
+                    ntype: NodeType::Entity.into(),
+                    subtype: "PERSON".to_string(),
+                    value: "Úrsula Usuaria".to_string(),
+                }),
+                relation: RelationType::Entity.into(),
+                relation_label: "SAME".to_string(),
+                metadata: None,
+            }),
+            facets: vec!["/g/u".to_string()],
+            ..Default::default()
+        },
+        IndexRelation {
+            relation: Some(nidx_protos::Relation {
+                source: Some(RelationNode {
+                    ntype: NodeType::Entity.into(),
+                    subtype: "PERSON".to_string(),
+                    value: "Alfred Agent".to_string(),
+                }),
+                to: Some(RelationNode {
+                    ntype: NodeType::Entity.into(),
+                    subtype: "PERSON".to_string(),
+                    value: "Alfred Agente".to_string(),
+                }),
+                relation: RelationType::Entity.into(),
+                relation_label: "SAME".to_string(),
+                metadata: None,
+            }),
+            facets: vec!["/g/da/mytask".to_string()],
+            ..Default::default()
+        },
+    ];
+    let field_relations = HashMap::from([("a/metadata".to_string(), IndexRelations { relations })]);
+    let resource = Resource {
+        resource: Some(ResourceId {
+            uuid: "0123456789abcdef0123456789abcdef".to_string(),
+            shard_id: "shard_id".to_string(),
+        }),
+        field_relations,
+        ..Default::default()
+    };
+
+    let segment_meta = RelationIndexer
+        .index_resource(dir.path(), &RelationConfig::default(), &resource)
+        .unwrap()
+        .unwrap();
+    let reader = RelationSearcher::open(
+        RelationConfig::default(),
+        TestOpener::new(vec![(segment_meta, 1i64.into())], vec![]),
+    )?;
+
+    // Everything
+    let result = search(&reader, Query::Path(Path::default()))?;
+    assert_eq!(result.relations.len(), 3);
+
+    // Processor
+    let result = search(
+        &reader,
+        Query::BoolNot(Box::new(PathQuery {
+            query: Some(Query::Facet(FacetFilter {
+                facet: "/g".to_string(),
+            })),
+        })),
+    )?;
+    assert_eq!(result.relations.len(), 1);
+    assert_eq!(result.nodes[0].value, "Peter Processor");
+
+    // User
+    let result = search(
+        &reader,
+        Query::Facet(FacetFilter {
+            facet: "/g/u".to_string(),
+        }),
+    )?;
+    assert_eq!(result.relations.len(), 1);
+    assert_eq!(result.nodes[0].value, "Ursula User");
+
+    // Any DA
+    let result = search(
+        &reader,
+        Query::Facet(FacetFilter {
+            facet: "/g/da".to_string(),
+        }),
+    )?;
+    assert_eq!(result.relations.len(), 1);
+    assert_eq!(result.nodes[0].value, "Alfred Agent");
+
+    // Specific DA
+    let result = search(
+        &reader,
+        Query::Facet(FacetFilter {
+            facet: "/g/da/mytask".to_string(),
+        }),
+    )?;
+    assert_eq!(result.relations.len(), 1);
+    assert_eq!(result.nodes[0].value, "Alfred Agent");
+
+    // Non-existing facet
+    let result = search(
+        &reader,
+        Query::Facet(FacetFilter {
+            facet: "/g/da/faketask".to_string(),
+        }),
+    )?;
+    assert_eq!(result.relations.len(), 0);
+
+    Ok(())
+}
+
 fn create_reader() -> anyhow::Result<RelationSearcher> {
     let dir = TempDir::new().unwrap();
 

{nidx_binding-6.3.4.post154 → nidx_binding-6.3.4.post159}/pyproject.toml

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