fmt

Author: fabianmurariu

raphtory-graphql/src/lib.rs

@@ -536,7 +536,6 @@ mod graphql_test {
         graph
     }
 
-
     fn degree_graph_with_add_edge_only() -> Graph {
         let graph = Graph::new();
 
@@ -646,8 +645,6 @@ mod graphql_test {
         );
     }
 
-    
-
     #[tokio::test]
     async fn test_unique_temporal_properties() {
         let g = Graph::new();

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

@@ -1,4 +1,7 @@
-use crate::model::{graph::{node_id::GqlNodeId, property::Value, timeindex::GqlTimeInput}, plugins::operation};
+use crate::model::{
+    graph::{node_id::GqlNodeId, property::Value, timeindex::GqlTimeInput},
+    plugins::operation,
+};
 use async_graphql::dynamic::ValueAccessor;
 use dynamic_graphql::{
     internal::{
@@ -7,16 +10,35 @@ use dynamic_graphql::{
     Enum, InputObject, OneOfInput,
 };
 use raphtory::{
-    db::{api::{state::ops::Degree, view::internal::filtered_edge}, graph::views::filter::model::{
-        ComposableFilter, DynFilter, DynView, NoFilter, ViewWrapOps, degree_filter::DegreeFilter, edge_filter::{CompositeEdgeFilter, EdgeFilter}, filter::{Filter, FilterValue}, filter_operator::FilterOperator, graph_filter::GraphFilter, is_active_edge_filter::IsActiveEdge, is_active_node_filter::IsActiveNode, is_deleted_filter::IsDeletedEdge, is_self_loop_filter::IsSelfLoopEdge, is_valid_filter::IsValidEdge, latest_filter::Latest as LatestWrap, layered_filter::Layered, node_filter::{CompositeNodeFilter, NodeFilter}, property_filter::{Op, PropertyFilter, PropertyFilterValue, PropertyRef}, snapshot_filter::{SnapshotAt as SnapshotAtWrap, SnapshotLatest as SnapshotLatestWrap}, windowed_filter::Windowed
-    }},
+    db::{
+        api::{state::ops::Degree, view::internal::filtered_edge},
+        graph::views::filter::model::{
+            degree_filter::DegreeFilter,
+            edge_filter::{CompositeEdgeFilter, EdgeFilter},
+            filter::{Filter, FilterValue},
+            filter_operator::FilterOperator,
+            graph_filter::GraphFilter,
+            is_active_edge_filter::IsActiveEdge,
+            is_active_node_filter::IsActiveNode,
+            is_deleted_filter::IsDeletedEdge,
+            is_self_loop_filter::IsSelfLoopEdge,
+            is_valid_filter::IsValidEdge,
+            latest_filter::Latest as LatestWrap,
+            layered_filter::Layered,
+            node_filter::{CompositeNodeFilter, NodeFilter},
+            property_filter::{Op, PropertyFilter, PropertyFilterValue, PropertyRef},
+            snapshot_filter::{SnapshotAt as SnapshotAtWrap, SnapshotLatest as SnapshotLatestWrap},
+            windowed_filter::Windowed,
+            ComposableFilter, DynFilter, DynView, NoFilter, ViewWrapOps,
+        },
+    },
     errors::GraphError,
 };
-use raphtory_api::core::Direction;
 use raphtory_api::core::{
     entities::{properties::prop::Prop, Layer, GID},
     storage::timeindex::{AsTime, EventTime},
     utils::time::IntoTime,
+    Direction,
 };
 use serde::{Deserialize, Serialize};
 use std::{
@@ -304,7 +326,6 @@ pub struct PropertyFilterNew {
     pub where_: PropCondition,
 }
 
-
 /// Filters nodes by computed degree with a directional scope.
 ///
 /// `DegreeFilterNew` lets callers filter on:
@@ -330,8 +351,8 @@ pub enum DegreeDirection {
 impl From<DegreeDirection> for Direction {
     fn from(d: DegreeDirection) -> Self {
         match d {
-            DegreeDirection::In   => Direction::IN,
-            DegreeDirection::Out  => Direction::OUT,
+            DegreeDirection::In => Direction::IN,
+            DegreeDirection::Out => Direction::OUT,
             DegreeDirection::Both => Direction::BOTH,
         }
     }
@@ -342,7 +363,7 @@ impl From<DegreeDirection> for String {
         match d {
             DegreeDirection::In => "in_degree".to_string(),
             DegreeDirection::Out => "out_degree".to_string(),
-            DegreeDirection::Both => "degree".to_string(), 
+            DegreeDirection::Both => "degree".to_string(),
         }
     }
 }
@@ -1440,8 +1461,8 @@ impl TryFrom<GqlNodeFilter> for CompositeNodeFilter {
                     direction: core_direction,
                     operator,
                     value,
-                    ops
-                })) 
+                    ops,
+                }))
             }
             GqlNodeFilter::Property(prop) => {
                 let prop_ref = PropertyRef::Property(prop.name.clone());

raphtory-tests/tests/test_filters.rs

@@ -1647,32 +1647,38 @@ fn init_edges_graph_with_str_ids_del<
 
 mod test_node_filter {
 
-use crate::{
+    use crate::{
         init_nodes_graph, init_nodes_graph_with_num_ids, init_nodes_graph_with_str_ids,
         IdentityGraphTransformer,
     };
+    use proptest::proptest;
     use raphtory::{
-        algorithms::alternating_mask::alternating_mask, core::entities::VID, db::{
-            api::view::{Filter, filter_ops::NodeSelect},
-            graph::{
-                views::filter::{
-                    CreateFilter, model::{
-                        ComposableFilter, CompositeNodeFilter, NodeViewFilterOps, PropertyFilterFactory, TryAsCompositeFilter, ViewWrapOps, degree_filter::DegreeFilterFactory, node_filter::ops::{NodeFilterOps, NodeIdFilterOps}, property_filter::ops::{ListAggOps, PropertyFilterOps}
-                    }
+        algorithms::alternating_mask::alternating_mask,
+        core::entities::VID,
+        db::{
+            api::view::{filter_ops::NodeSelect, Filter},
+            graph::views::filter::{
+                model::{
+                    degree_filter::DegreeFilterFactory,
+                    node_filter::ops::{NodeFilterOps, NodeIdFilterOps},
+                    property_filter::ops::{ElemQualifierOps, ListAggOps, PropertyFilterOps},
+                    ComposableFilter, CompositeNodeFilter, NodeViewFilterOps,
+                    PropertyFilterFactory, TryAsCompositeFilter, ViewWrapOps,
                 },
+                CreateFilter,
             },
-        }, errors::GraphError, prelude::{
-            AdditionOps, Graph, GraphViewOps, NO_PROPS, NodeFilter, NodeStateOps, NodeViewOps, TimeOps
-        }
+        },
+        errors::GraphError,
+        prelude::{
+            AdditionOps, Graph, GraphViewOps, IntoProp, NodeFilter, NodeStateOps, NodeViewOps,
+            TimeOps, NO_PROPS,
+        },
     };
+    use raphtory_api::core::{entities::properties::prop::Prop, Direction};
     use raphtory_tests::assertions::{
         assert_filter_nodes_results, assert_search_nodes_results, assert_select_nodes_results,
         TestVariants,
     };
-    use raphtory_api::core::{Direction, entities::properties::prop::Prop};
-    use raphtory::prelude::IntoProp;
-    use raphtory::db::graph::views::filter::model::property_filter::ops::ElemQualifierOps;
-    use proptest::proptest;
 
     fn sort_vids(mut vids: Vec<VID>) -> Vec<VID> {
         vids.sort();
@@ -1717,7 +1723,8 @@ use crate::{
             .map(|n| n.node)
             .collect::<Vec<_>>();
 
-        let expected_filter_nodes = candidates_with_history_after_filtering(graph, expected_select_nodes.clone());
+        let expected_filter_nodes =
+            candidates_with_history_after_filtering(graph, expected_select_nodes.clone());
 
         let filtered_event_graph = graph.filter(filter.clone()).unwrap();
         let filtered_event_nodes = sort_vids(
@@ -1799,7 +1806,6 @@ use crate::{
         graph
     }
 
-
     fn degree_graph_with_add_edge_only() -> Graph {
         let graph = Graph::new();
 
@@ -1844,7 +1850,6 @@ use crate::{
         graph
     }
 
-
     // Property-based tests for degree filtering
     proptest! {
         #[test]
@@ -2033,7 +2038,7 @@ use crate::{
                 |d| d > threshold as usize && d < (threshold + 5) as usize,
                 &format!("OUT > {} AND OUT < {}", threshold, threshold + 5),
             );
-        } 
+        }
 
         #[test]
         fn prop_degree_filter_or(threshold in 0u64..15) {
@@ -2158,7 +2163,7 @@ use crate::{
                 &format!("OUT is_not_in({}, {})", val1, val2),
             );
         }
-    } 
+    }
 
     #[test]
     fn test_degree_filter_with_invalid_expressions() {
@@ -13021,4 +13026,3 @@ mod test_edge_composite_filter {
         );
     }
 }
-

raphtory/src/arrow_loader/df_loaders/nodes.rs

@@ -40,7 +40,8 @@ use crate::arrow_loader::df_loaders::build_progress_bar;
 use crate::arrow_loader::{
     dataframe::{DFChunk, DFView},
     df_loaders::{
-        extract_secondary_index_col, process_shared_properties, resolve_nodes_and_type_with_cache,
+        extract_secondary_index_col, group_rows_by_vid_segment, process_shared_properties,
+        resolve_nodes_and_type_with_cache, secondary_index_at,
     },
     layer_col::{lift_layer_col, lift_node_type_col, LayerCol},
     node_col::NodeCol,
@@ -49,7 +50,6 @@ use crate::arrow_loader::{
 };
 #[cfg(feature = "progress")]
 use kdam::BarExt;
-use crate::arrow_loader::df_loaders::{group_rows_by_vid_segment, secondary_index_at};
 
 /// If layer_id_col is provided, then layer_col must also be provided
 #[allow(clippy::too_many_arguments)]

raphtory/src/db/api/state/ops/filter.rs

@@ -2,18 +2,25 @@ use crate::{
     db::{
         api::{
             state::{
-                Index, ops::{Const, Degree, IntoDynNodeOp, NodeOp, TypeId}
+                ops::{Const, Degree, IntoDynNodeOp, NodeOp, TypeId},
+                Index,
             },
             view::internal::{GraphView, NodeList},
         },
         graph::{
             create_node_type_filter,
-            views::filter::model::{FilterOperator, degree_filter::DegreeFilter, filter::{Filter, FilterValue}, node_filter::NodeFilter, property_filter::PropertyFilterValue}, 
+            views::filter::model::{
+                degree_filter::DegreeFilter,
+                filter::{Filter, FilterValue},
+                node_filter::NodeFilter,
+                property_filter::PropertyFilterValue,
+                FilterOperator,
+            },
         },
     },
     prelude::{GraphViewOps, PropertyFilter},
 };
-use raphtory_api::core::entities::{VID, properties::prop::Prop};
+use raphtory_api::core::entities::{properties::prop::Prop, VID};
 use raphtory_core::entities::nodes::node_ref::AsNodeRef;
 use raphtory_storage::graph::{graph::GraphStorage, nodes::node_storage_ops::NodeStorageOps};
 use std::sync::Arc;
@@ -225,19 +232,19 @@ impl<G: GraphView> NodeOp for NodePropertyFilterOp<G> {
 pub struct NodeDegreeFilterOp<G> {
     degree: Degree<G>,
     operator: FilterOperator,
-    value: PropertyFilterValue
+    value: PropertyFilterValue,
 }
 
 impl<G> NodeDegreeFilterOp<G> {
     pub(crate) fn new(graph: G, filter: DegreeFilter) -> Self {
         let degree = Degree {
             dir: filter.direction,
-            view: graph 
+            view: graph,
         };
         Self {
             degree,
             operator: filter.operator,
-            value: filter.value
+            value: filter.value,
         }
     }
 }
@@ -248,7 +255,8 @@ impl<G: GraphView> NodeOp for NodeDegreeFilterOp<G> {
     fn apply(&self, storage: &GraphStorage, node: VID) -> Self::Output {
         let node_degree = self.degree.apply(storage, node);
         let node_degree_prop = Prop::U64(node_degree as u64);
-        self.operator.apply_to_property(&self.value, Some(&node_degree_prop))
+        self.operator
+            .apply_to_property(&self.value, Some(&node_degree_prop))
     }
 }