Added src/dst endpoint filtering support for exploded edge filters in rust and python

Author: arienandalibi

raphtory/src/db/graph/views/filter/model/exploded_edge_filter.rs

@@ -16,9 +16,13 @@ use crate::{
 };
 use raphtory_core::utils::time::IntoTime;
 use std::{fmt, fmt::Display, ops::Deref, sync::Arc};
+use crate::db::graph::views::filter::edge_node_filtered_graph::EdgeNodeFilteredGraph;
+use crate::db::graph::views::filter::model::edge_filter::{EdgeEndpoint, Endpoint};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum CompositeExplodedEdgeFilter {
+    Src(CompositeNodeFilter),
+    Dst(CompositeNodeFilter),
     Property(PropertyFilter<ExplodedEdgeFilter>),
     And(
         Box<CompositeExplodedEdgeFilter>,
@@ -34,6 +38,8 @@ pub enum CompositeExplodedEdgeFilter {
 impl Display for CompositeExplodedEdgeFilter {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
+            CompositeExplodedEdgeFilter::Src(filter) => write!(f, "SRC({})", filter),
+            CompositeExplodedEdgeFilter::Dst(filter) => write!(f, "DST({})", filter),
             CompositeExplodedEdgeFilter::Property(filter) => write!(f, "{}", filter),
             CompositeExplodedEdgeFilter::And(left, right) => write!(f, "({} AND {})", left, right),
             CompositeExplodedEdgeFilter::Or(left, right) => write!(f, "({} OR {})", left, right),
@@ -66,6 +72,22 @@ impl CreateFilter for CompositeExplodedEdgeFilter {
         graph: G,
     ) -> Result<Self::EntityFiltered<'graph, G>, GraphError> {
         match self {
+            CompositeExplodedEdgeFilter::Src(filter) => {
+                let filtered_graph = filter.clone().create_filter(graph.clone())?;
+                Ok(Arc::new(EdgeNodeFilteredGraph::new(
+                    graph,
+                    Endpoint::Src,
+                    filtered_graph
+                )))
+            },
+            CompositeExplodedEdgeFilter::Dst(filter) => {
+                let filtered_graph = filter.clone().create_filter(graph.clone())?;
+                Ok(Arc::new(EdgeNodeFilteredGraph::new(
+                    graph,
+                    Endpoint::Dst,
+                    filtered_graph
+                )))
+            },
             CompositeExplodedEdgeFilter::Property(i) => Ok(Arc::new(i.create_filter(graph)?)),
             CompositeExplodedEdgeFilter::And(l, r) => Ok(Arc::new(
                 AndFilter {
@@ -109,6 +131,16 @@ pub struct ExplodedEdgeFilter;
 impl PropertyFilterFactory<ExplodedEdgeFilter> for ExplodedEdgeFilter {}
 
 impl ExplodedEdgeFilter {
+    #[inline]
+    pub fn src() -> EdgeEndpoint {
+        EdgeEndpoint::src()
+    }
+
+    #[inline]
+    pub fn dst() -> EdgeEndpoint {
+        EdgeEndpoint::dst()
+    }
+
     #[inline]
     pub fn window<S: IntoTime, E: IntoTime>(start: S, end: E) -> Windowed<ExplodedEdgeFilter> {
         Windowed::from_times(start, end)

raphtory/src/python/filter/edge_filter_builders.rs

@@ -17,6 +17,7 @@ use crate::{
 use pyo3::{exceptions::PyTypeError, pyclass, pymethods, Bound, PyAny, PyResult};
 use raphtory_api::core::entities::GID;
 use std::sync::Arc;
+use crate::db::graph::views::filter::model::exploded_edge_filter::ExplodedEdgeFilter;
 
 #[pyclass(frozen, name = "EdgeEndpoint", module = "raphtory.filter")]
 #[derive(Clone)]
@@ -97,6 +98,16 @@ pub struct PyExplodedEdgeFilter;
 
 #[pymethods]
 impl PyExplodedEdgeFilter {
+    #[staticmethod]
+    fn src() -> PyEdgeEndpoint {
+        PyEdgeEndpoint(EdgeFilter::src())
+    }
+
+    #[staticmethod]
+    fn dst() -> PyEdgeEndpoint {
+        PyEdgeEndpoint(EdgeFilter::dst())
+    }
+    
     #[staticmethod]
     fn property(name: String) -> PropertyFilterBuilder<ExplodedEdgeFilter> {
         ExplodedEdgeFilter::property(name)