impl node type filter for nodes, pathfromgraph and pathfromnode

python/tests/test_graphdb.py

@@ -2046,15 +2046,92 @@ def test_one_hop_filter_reset():
     assert len(out_out_2) == 0
 
 
-def test_node_types():
+def test_type_filter():
     g = Graph()
     g.add_node(1, 1, node_type="wallet")
     g.add_node(1, 2, node_type="timer")
     g.add_node(1, 3, node_type="timer")
     g.add_node(1, 4, node_type="wallet")
 
-    assert g.nodes.type_filter(["wallet"]).node_type.collect() == ["1", "4"]
-    assert g.subgraph_node_types(["timer"]).nodes.name.collect() == ["2", "3"]
+    assert [node.name for node in g.nodes.type_filter(["wallet"])] == ['1', '4']
+    assert g.subgraph_node_types(["timer"]).nodes.name.collect() == ['2', '3']
+
+    g = PersistentGraph()
+    g.add_node(1, 1, node_type="wallet")
+    g.add_node(2, 2, node_type="timer")
+    g.add_node(3, 3, node_type="timer")
+    g.add_node(4, 4, node_type="wallet")
+
+    assert [node.name for node in g.nodes.type_filter(["wallet"])] == ['1', '4']
+    assert g.subgraph_node_types(["timer"]).nodes.name.collect() == ['2', '3']
+
+    subgraph = g.subgraph([1, 2, 3])
+    assert [node.name for node in subgraph.nodes.type_filter(["wallet"])] == ['1']
+    assert subgraph.subgraph_node_types(["timer"]).nodes.name.collect() == ['2', '3']
+
+    w = g.window(1, 3)
+    assert [node.name for node in w.nodes.type_filter(["wallet"])] == ['1']
+    assert w.subgraph_node_types(["timer"]).nodes.name.collect() == ['2', '3']
+
+    g = Graph()
+    g.add_node(1, 1, node_type="wallet")
+    g.add_node(2, 2, node_type="timer")
+    g.add_node(3, 3, node_type="timer")
+    g.add_node(4, 4, node_type="counter")
+    g.add_edge(1, 1, 2, layer="layer1")
+    g.add_edge(2, 2, 3, layer="layer1")
+    g.add_edge(3, 2, 4, layer="layer2")
+    layer = g.layers(["layer1"])
+    assert [node.name for node in layer.nodes.type_filter(["wallet"])] == ['1']
+    assert layer.subgraph_node_types(["timer"]).nodes.name.collect() == ['2', '3']
+
+    g = Graph()
+    g.add_node(1, 1, node_type="a")
+    g.add_node(1, 2, node_type="b")
+    g.add_node(1, 3, node_type="b")
+    g.add_node(1, 4, node_type="a")
+    g.add_node(1, 5, node_type="c")
+    g.add_node(1, 6, node_type="e")
+    g.add_edge(2, 1, 2, layer="a")
+    g.add_edge(2, 3, 2, layer="a")
+    g.add_edge(2, 2, 4, layer="a")
+    g.add_edge(2, 4, 5, layer="a")
+    g.add_edge(2, 4, 5, layer="a")
+    g.add_edge(2, 5, 6, layer="a")
+    g.add_edge(2, 3, 6, layer="a")
+
+    assert g.nodes.type_filter(["a"]).name.collect() == ['1', '4']
+    assert g.nodes.type_filter(["a", "c"]).name.collect() == ['1', '4', '5']
+    assert g.nodes.type_filter(["a"]).neighbours.name.collect() == [['2'], ['2', '5']]
+
+    assert g.nodes.degree().collect() == [1, 3, 2, 2, 2, 2]
+    assert g.nodes.type_filter(['a']).degree().collect() == [1, 2]
+    assert g.nodes.type_filter(['d']).degree().collect() == []
+    assert g.nodes.type_filter([]).name.collect() == []
+
+    assert len(g.nodes) == 6
+    assert len(g.nodes.type_filter(['b'])) == 2
+    assert len(g.nodes.type_filter(['d'])) == 0
+
+    assert g.nodes.type_filter(['d']).neighbours.name.collect() == []
+    assert g.nodes.type_filter(['a']).neighbours.name.collect() == [['2'], ['2', '5']]
+    assert g.nodes.type_filter(['a', 'c']).neighbours.name.collect() == [['2'], ['2', '5'], ['4', '6']]
+
+    assert g.nodes.type_filter(['a']).neighbours.type_filter(['c']).name.collect() == [[], ['5']]
+    assert g.nodes.type_filter(['a']).neighbours.type_filter([]).name.collect() == [[], []]
+    assert g.nodes.type_filter(['a']).neighbours.type_filter(['b', 'c']).name.collect() == [['2'], ['2', '5']]
+    assert g.nodes.type_filter(['a']).neighbours.type_filter(['d']).name.collect() == [[], []]
+    assert g.nodes.type_filter(['a']).neighbours.neighbours.name.collect() == [['1', '3', '4'], ['1', '3', '4', '4', '6']]
+    assert g.nodes.type_filter(['a']).neighbours.type_filter(['c']).neighbours.name.collect() == [[], ['4', '6']]
+    assert g.nodes.type_filter(['a']).neighbours.type_filter(['d']).neighbours.name.collect() == [[], []]
+
+    assert g.node('2').neighbours.type_filter(['b']).name.collect() == ['3']
+    assert g.node('2').neighbours.type_filter(['d']).name.collect() == []
+    assert g.node('2').neighbours.type_filter([]).name.collect() == []
+    assert g.node('2').neighbours.type_filter(['c', 'a']).name.collect() == ['1', '4']
+    assert g.node('2').neighbours.type_filter(['c']).neighbours.name.collect() == []
+    assert g.node('2').neighbours.neighbours.name.collect() == ['2', '2', '6', '2', '5']
+
 
 
 def test_time_exploded_edges():

raphtory-graphql/src/lib.rs

@@ -969,4 +969,120 @@ mod graphql_test {
         let graph_roundtrip = url_decode_graph(graph_encoded).unwrap().into_dynamic();
         assert_eq!(g, graph_roundtrip);
     }
+
+    #[tokio::test]
+    async fn test_type_filter() {
+        let graph = Graph::new();
+        graph.add_constant_properties([("name", "graph")]).unwrap();
+        graph.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
+        graph.add_node(1, 2, NO_PROPS, Some("b")).unwrap();
+        graph.add_node(1, 3, NO_PROPS, Some("b")).unwrap();
+        graph.add_node(1, 4, NO_PROPS, Some("a")).unwrap();
+        graph.add_node(1, 5, NO_PROPS, Some("c")).unwrap();
+        graph.add_node(1, 6, NO_PROPS, Some("e")).unwrap();
+        graph.add_edge(2, 1, 2, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 3, 2, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 2, 4, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 4, 5, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 4, 5, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 5, 6, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 3, 6, NO_PROPS, Some("a")).unwrap();
+
+        let graphs = HashMap::from([("graph".to_string(), graph)]);
+        let data = Data::from_map(graphs);
+        let schema = App::create_schema().data(data).finish().unwrap();
+
+        let req = r#"
+        {
+          graph(name: "graph") {
+            nodes {
+              typeFilter(nodeTypes: ["a"]) {
+                list {
+                  name
+                }
+              }
+            }
+          }
+        }
+        "#;
+
+        let req = Request::new(req);
+        let res = schema.execute(req).await;
+        let data = res.data.into_json().unwrap();
+        assert_eq!(
+            data,
+            json!({
+                "graph": {
+                  "nodes": {
+                    "typeFilter": {
+                      "list": [
+                        {
+                          "name": "1"
+                        },
+                        {
+                          "name": "4"
+                        }
+                      ]
+                    }
+                  }
+                }
+            }),
+        );
+
+        let req = r#"
+        {
+          graph(name: "graph") {
+            nodes {
+              typeFilter(nodeTypes: ["a"]) {
+                list{
+                  neighbours {
+                    list {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        "#;
+
+        let req = Request::new(req);
+        let res = schema.execute(req).await;
+        let data = res.data.into_json().unwrap();
+        assert_eq!(
+            data,
+            json!({
+                "graph": {
+                  "nodes": {
+                    "typeFilter": {
+                      "list": [
+                        {
+                          "neighbours": {
+                            "list": [
+                              {
+                                "name": "2"
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          "neighbours": {
+                            "list": [
+                              {
+                                "name": "2"
+                              },
+                              {
+                                "name": "5"
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  }
+                }
+            }),
+        );
+    }
 }

raphtory-graphql/src/model/graph/nodes.rs

@@ -78,7 +78,7 @@ impl GqlNodes {
     }
 
     async fn type_filter(&self, node_types: Vec<String>) -> Self {
-        self.update(self.nn.type_filter(node_types))
+        self.update(self.nn.type_filter(&node_types))
     }
 
     ////////////////////////

raphtory-graphql/src/model/graph/path_from_node.rs

@@ -79,7 +79,7 @@ impl GqlPathFromNode {
     }
 
     async fn type_filter(&self, node_types: Vec<String>) -> Self {
-        self.update(self.nn.type_filter(node_types))
+        self.update(self.nn.type_filter(&node_types))
     }
 
     ////////////////////////

raphtory-graphql/src/model/graph/property.rs

@@ -9,7 +9,7 @@ use raphtory::{
     },
 };
 use serde_json::Number;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 #[derive(Clone, Debug, Scalar)]
 pub struct GqlPropValue(pub Prop);

raphtory/src/arrow/graph_impl/core_ops.rs

@@ -28,13 +28,17 @@ use crate::{
             },
             storage_ops::GraphStorage,
         },
-        view::{internal::CoreGraphOps, BoxedIter},
+        view::{
+            internal::{CoreGraphOps, DelegateCoreOps},
+            BoxedIter,
+        },
     },
 };
 use itertools::Itertools;
 use polars_arrow::datatypes::ArrowDataType;
 use raphtory_arrow::{properties::Properties, GidRef, GID};
 use rayon::prelude::*;
+
 impl CoreGraphOps for ArrowGraph {
     fn unfiltered_num_nodes(&self) -> usize {
         self.inner.num_nodes()
@@ -222,6 +226,11 @@ impl CoreGraphOps for ArrowGraph {
             .map(|layer| layer.num_edges())
             .sum()
     }
+
+    fn node_type_id(&self, v: VID) -> usize {
+        // self.graph().node_type_id(v) TODO: Impl node types for arrow graphs
+        0
+    }
 }
 
 pub fn const_props<Index>(props: &Properties<Index>, index: Index, id: usize) -> Option<Prop>

raphtory/src/arrow/graph_impl/edge_storage_ops.rs

@@ -8,8 +8,8 @@ use crate::{
         edges::edge_storage_ops::{EdgeStorageOps, TimeIndexRef},
         tprop_storage_ops::TPropOps,
     },
-    prelude::TimeIndexEntry,
 };
+use raphtory_api::core::storage::timeindex::TimeIndexEntry;
 use raphtory_arrow::{edge::Edge, tprops::ArrowTProp};
 use rayon::prelude::*;
 use std::{iter, ops::Range};

raphtory/src/arrow/graph_impl/interop.rs

@@ -16,7 +16,10 @@ use crate::{
 };
 use itertools::Itertools;
 use polars_arrow::array::Array;
-use raphtory_api::core::entities::{EID, VID};
+use raphtory_api::core::{
+    entities::{EID, VID},
+    storage::timeindex::TimeIndexEntry,
+};
 use raphtory_arrow::interop::GraphLike;
 
 impl GraphLike<TimeIndexEntry> for Graph {

raphtory/src/arrow/graph_impl/mod.rs

@@ -28,8 +28,6 @@ pub mod const_properties_ops;
 pub mod core_ops;
 pub mod edge_filter_ops;
 mod edge_storage_ops;
-pub mod graph_ops;
-
 mod interop;
 pub mod layer_ops;
 mod list_ops;

raphtory/src/arrow/graph_impl/time_index_into_ops.rs

@@ -1,8 +1,8 @@
 use crate::{
     core::storage::timeindex::{TimeIndexIntoOps, TimeIndexOps},
     db::api::view::IntoDynBoxed,
-    prelude::TimeIndexEntry,
 };
+use raphtory_api::core::storage::timeindex::TimeIndexEntry;
 use raphtory_arrow::{
     prelude::{ArrayOps, BaseArrayOps},
     timestamps::TimeStamps,

raphtory/src/arrow/graph_impl/time_semantics.rs

@@ -16,6 +16,7 @@ use crate::{
     prelude::*,
 };
 use itertools::Itertools;
+use raphtory_api::core::storage::timeindex::TimeIndexEntry;
 use rayon::prelude::*;
 use std::{iter, ops::Range};
 

raphtory/src/arrow/graph_impl/tprops.rs

@@ -5,8 +5,9 @@ use crate::{
     },
     core::storage::timeindex::TimeIndexIntoOps,
     db::api::{storage::tprop_storage_ops::TPropOps, view::IntoDynBoxed},
-    prelude::{Prop, TimeIndexEntry},
+    prelude::Prop,
 };
+use raphtory_api::core::storage::timeindex::TimeIndexEntry;
 use raphtory_arrow::{
     chunked_array::{col::ChunkedPrimitiveCol, utf8_col::StringCol},
     edge::Edge,

raphtory/src/arrow/storage_interface/edge.rs

@@ -4,8 +4,8 @@ use crate::{
         storage::timeindex::TimeIndexOps,
     },
     db::api::storage::edges::edge_storage_ops::EdgeStorageIntoOps,
-    prelude::TimeIndexEntry,
 };
+use raphtory_api::core::storage::timeindex::TimeIndexEntry;
 use raphtory_arrow::{edge::Edge, edges::Edges, graph::TemporalGraph, timestamps::TimeStamps};
 use std::ops::Range;
 

raphtory/src/core/entities/graph/tgraph.rs

@@ -238,6 +238,11 @@ impl TemporalGraph {
         self.node_meta.get_node_type_name_by_id(node.node_type)
     }
 
+    pub(crate) fn node_type_id(&self, v: VID) -> usize {
+        let node = self.storage.get_node(v);
+        node.node_type
+    }
+
     pub(crate) fn get_all_node_types(&self) -> Vec<ArcStr> {
         self.node_meta.get_all_node_types()
     }

raphtory/src/core/mod.rs

@@ -50,7 +50,7 @@ extern crate core;
 
 pub mod entities;
 pub mod state;
-pub(crate) mod storage;
+pub mod storage;
 pub mod utils;
 
 // this is here because Arc<str> annoyingly doesn't implement all the expected comparisons

raphtory/src/core/storage/timeindex.rs

@@ -6,6 +6,7 @@ use crate::{
 use chrono::{DateTime, NaiveDateTime, Utc};
 use itertools::Itertools;
 use num_traits::Saturating;
+use raphtory_api::core::entities::VID;
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::{

raphtory/src/db/api/storage/edges/edge_owned_entry.rs

@@ -17,8 +17,8 @@ use crate::{
         },
         tprop_storage_ops::TPropOps,
     },
-    prelude::TimeIndexEntry,
 };
+use raphtory_api::core::storage::timeindex::TimeIndexEntry;
 use rayon::iter::ParallelIterator;
 use std::ops::Range;