Do not rely on Wrap for the trait bounds in the builder API as the compiler cannot figure out the bounds when trying to implement python wrappers.

Author: ljeub-pometry

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

@@ -15,7 +15,8 @@ use crate::{
                     NodeNameFilterBuilder, NodeTypeFilterBuilder,
                 },
                 property_filter::{
-                    InternalPropertyFilterBuilderOps, Op, PropertyFilter, PropertyRef,
+                    InternalPropertyFilterBuilderOps, Op, OpChainBuilder, PropertyFilter,
+                    PropertyRef,
                 },
                 AndFilter, EntityMarker, NotFilter, OrFilter, TryAsCompositeFilter, Windowed, Wrap,
             },
@@ -204,6 +205,8 @@ impl EndpointWrapper<NodeFilter> {
 }
 
 impl<T: InternalPropertyFilterBuilderOps> InternalPropertyFilterBuilderOps for EndpointWrapper<T> {
+    type Filter = EndpointWrapper<T::Filter>;
+    type Chained = EndpointWrapper<T::Chained>;
     type Marker = T::Marker;
 
     #[inline]
@@ -220,6 +223,14 @@ impl<T: InternalPropertyFilterBuilderOps> InternalPropertyFilterBuilderOps for E
     fn entity(&self) -> Self::Marker {
         self.inner.entity()
     }
+
+    fn filter(&self, filter: PropertyFilter<Self::Marker>) -> Self::Filter {
+        self.wrap(self.inner.filter(filter))
+    }
+
+    fn chained(&self, builder: OpChainBuilder<Self::Marker>) -> Self::Chained {
+        self.wrap(self.inner.chained(builder))
+    }
 }
 
 impl<T: InternalNodeFilterBuilderOps> InternalNodeFilterBuilderOps for EndpointWrapper<T> {

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

@@ -15,8 +15,8 @@ use crate::{
                     InternalNodeIdFilterBuilderOps, NodeFilter,
                 },
                 property_filter::{
-                    InternalPropertyFilterBuilderOps, MetadataFilterBuilder, Op, PropertyFilter,
-                    PropertyFilterBuilder, PropertyRef,
+                    InternalPropertyFilterBuilderOps, MetadataFilterBuilder, Op, OpChainBuilder,
+                    PropertyFilter, PropertyFilterBuilder, PropertyRef,
                 },
                 AndFilter, EntityMarker, NotFilter, OrFilter, TryAsCompositeFilter, Windowed, Wrap,
             },
@@ -253,6 +253,9 @@ where
 impl<T: InternalPropertyFilterBuilderOps> InternalPropertyFilterBuilderOps
     for ExplodedEndpointWrapper<T>
 {
+    type Filter = ExplodedEndpointWrapper<T::Filter>;
+    type Chained = ExplodedEndpointWrapper<T::Chained>;
+
     type Marker = T::Marker;
     #[inline]
     fn property_ref(&self) -> PropertyRef {
@@ -268,6 +271,14 @@ impl<T: InternalPropertyFilterBuilderOps> InternalPropertyFilterBuilderOps
     fn entity(&self) -> Self::Marker {
         self.inner.entity()
     }
+
+    fn filter(&self, filter: PropertyFilter<Self::Marker>) -> Self::Filter {
+        self.wrap(self.inner.filter(filter))
+    }
+
+    fn chained(&self, builder: OpChainBuilder<Self::Marker>) -> Self::Chained {
+        self.wrap(self.inner.chained(builder))
+    }
 }
 
 #[derive(Clone, Debug, Copy, Default, PartialEq, Eq)]

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

@@ -320,6 +320,8 @@ impl<T: InternalNodeIdFilterBuilderOps> InternalNodeIdFilterBuilderOps for Windo
 }
 
 impl<T: InternalPropertyFilterBuilderOps> InternalPropertyFilterBuilderOps for Windowed<T> {
+    type Filter = Windowed<T::Filter>;
+    type Chained = Windowed<T::Chained>;
     type Marker = T::Marker;
 
     fn property_ref(&self) -> PropertyRef {
@@ -333,6 +335,14 @@ impl<T: InternalPropertyFilterBuilderOps> InternalPropertyFilterBuilderOps for W
     fn entity(&self) -> Self::Marker {
         self.inner.entity()
     }
+
+    fn filter(&self, filter: PropertyFilter<Self::Marker>) -> Self::Filter {
+        self.wrap(self.inner.filter(filter))
+    }
+
+    fn chained(&self, builder: OpChainBuilder<Self::Marker>) -> Self::Chained {
+        self.wrap(self.inner.chained(builder))
+    }
 }
 
 impl<T: TryAsCompositeFilter> TryAsCompositeFilter for Windowed<T> {
@@ -478,105 +488,197 @@ impl<S: Wrap> Wrap for Arc<S> {
     }
 }
 
-pub trait InternalPropertyFilterFactory: Wrap {
+pub trait InternalPropertyFilterFactory {
     type Entity: Clone + Send + Sync + 'static;
+    type PropertyBuilder: InternalPropertyFilterBuilderOps + TemporalPropertyFilterFactory;
+    type MetadataBuilder: InternalPropertyFilterBuilderOps;
 
     fn entity(&self) -> Self::Entity;
+
+    fn property_builder(
+        &self,
+        builder: PropertyFilterBuilder<Self::Entity>,
+    ) -> Self::PropertyBuilder;
+
+    fn metadata_builder(
+        &self,
+        builder: MetadataFilterBuilder<Self::Entity>,
+    ) -> Self::MetadataBuilder;
 }
 
 pub trait PropertyFilterFactory: InternalPropertyFilterFactory {
-    fn property(
-        &self,
-        name: impl Into<String>,
-    ) -> Self::Wrapped<PropertyFilterBuilder<Self::Entity>> {
+    fn property(&self, name: impl Into<String>) -> Self::PropertyBuilder {
         let builder = PropertyFilterBuilder::new(name, self.entity());
-        self.wrap(builder)
+        self.property_builder(builder)
     }
 
-    fn metadata(
-        &self,
-        name: impl Into<String>,
-    ) -> Self::Wrapped<MetadataFilterBuilder<Self::Entity>> {
+    fn metadata(&self, name: impl Into<String>) -> Self::MetadataBuilder {
         let builder = MetadataFilterBuilder::new(name, self.entity());
-        self.wrap(builder)
+        self.metadata_builder(builder)
     }
 }
 
-impl<T: PropertyFilterFactory> PropertyFilterFactory for ExplodedEndpointWrapper<T> {}
+impl<T: InternalPropertyFilterFactory> PropertyFilterFactory for T {}
 
 pub trait TemporalPropertyFilterFactory: InternalPropertyFilterBuilderOps {
-    fn temporal(&self) -> Self::Wrapped<OpChainBuilder<Self::Marker>> {
+    fn temporal(&self) -> Self::Chained {
         let builder = OpChainBuilder {
             prop_ref: PropertyRef::TemporalProperty(self.property_ref().name().to_string()),
             ops: vec![],
             entity: self.entity(),
         };
-        self.wrap(builder)
+        self.chained(builder)
     }
 }
 
 impl InternalPropertyFilterFactory for NodeFilter {
     type Entity = NodeFilter;
+    type PropertyBuilder = PropertyFilterBuilder<NodeFilter>;
+    type MetadataBuilder = MetadataFilterBuilder<NodeFilter>;
 
     fn entity(&self) -> Self::Entity {
         NodeFilter
     }
-}
 
-impl PropertyFilterFactory for NodeFilter {}
+    fn property_builder(
+        &self,
+        builder: PropertyFilterBuilder<Self::Entity>,
+    ) -> Self::PropertyBuilder {
+        builder
+    }
+
+    fn metadata_builder(
+        &self,
+        builder: MetadataFilterBuilder<Self::Entity>,
+    ) -> Self::MetadataBuilder {
+        builder
+    }
+}
 
 impl InternalPropertyFilterFactory for EdgeFilter {
     type Entity = EdgeFilter;
+    type PropertyBuilder = PropertyFilterBuilder<EdgeFilter>;
+    type MetadataBuilder = MetadataFilterBuilder<EdgeFilter>;
 
     fn entity(&self) -> Self::Entity {
         EdgeFilter
     }
-}
 
-impl PropertyFilterFactory for EdgeFilter {}
+    fn property_builder(
+        &self,
+        builder: PropertyFilterBuilder<Self::Entity>,
+    ) -> Self::PropertyBuilder {
+        builder
+    }
+
+    fn metadata_builder(
+        &self,
+        builder: MetadataFilterBuilder<Self::Entity>,
+    ) -> Self::MetadataBuilder {
+        builder
+    }
+}
 
 impl InternalPropertyFilterFactory for ExplodedEdgeFilter {
     type Entity = ExplodedEdgeFilter;
+    type PropertyBuilder = PropertyFilterBuilder<ExplodedEdgeFilter>;
+    type MetadataBuilder = MetadataFilterBuilder<ExplodedEdgeFilter>;
 
     fn entity(&self) -> Self::Entity {
         ExplodedEdgeFilter
     }
-}
 
-impl PropertyFilterFactory for ExplodedEdgeFilter {}
+    fn property_builder(
+        &self,
+        builder: PropertyFilterBuilder<Self::Entity>,
+    ) -> Self::PropertyBuilder {
+        builder
+    }
+
+    fn metadata_builder(
+        &self,
+        builder: MetadataFilterBuilder<Self::Entity>,
+    ) -> Self::MetadataBuilder {
+        builder
+    }
+}
 
 impl<T: InternalPropertyFilterFactory> InternalPropertyFilterFactory for Windowed<T> {
     type Entity = T::Entity;
+    type PropertyBuilder = Windowed<T::PropertyBuilder>;
+    type MetadataBuilder = Windowed<T::MetadataBuilder>;
 
     fn entity(&self) -> Self::Entity {
         self.inner.entity()
     }
+
+    fn property_builder(
+        &self,
+        builder: PropertyFilterBuilder<Self::Entity>,
+    ) -> Self::PropertyBuilder {
+        self.wrap(self.inner.property_builder(builder))
+    }
+
+    fn metadata_builder(
+        &self,
+        builder: MetadataFilterBuilder<Self::Entity>,
+    ) -> Self::MetadataBuilder {
+        self.wrap(self.inner.metadata_builder(builder))
+    }
 }
 
 impl<T: TemporalPropertyFilterFactory> TemporalPropertyFilterFactory for Windowed<T> {}
 
-impl<T: PropertyFilterFactory> PropertyFilterFactory for Windowed<T> {}
-
 impl<T: InternalPropertyFilterFactory> InternalPropertyFilterFactory for EndpointWrapper<T> {
     type Entity = T::Entity;
+    type PropertyBuilder = EndpointWrapper<T::PropertyBuilder>;
+    type MetadataBuilder = EndpointWrapper<T::MetadataBuilder>;
 
     fn entity(&self) -> Self::Entity {
         self.inner.entity()
     }
+
+    fn property_builder(
+        &self,
+        builder: PropertyFilterBuilder<Self::Entity>,
+    ) -> Self::PropertyBuilder {
+        self.wrap(self.inner.property_builder(builder))
+    }
+
+    fn metadata_builder(
+        &self,
+        builder: MetadataFilterBuilder<Self::Entity>,
+    ) -> Self::MetadataBuilder {
+        self.wrap(self.inner.metadata_builder(builder))
+    }
 }
 
 impl<T: TemporalPropertyFilterFactory> TemporalPropertyFilterFactory for EndpointWrapper<T> {}
 
-impl<T: PropertyFilterFactory> PropertyFilterFactory for EndpointWrapper<T> {}
-
 impl<T: InternalPropertyFilterFactory> InternalPropertyFilterFactory
     for ExplodedEndpointWrapper<T>
 {
     type Entity = T::Entity;
+    type PropertyBuilder = ExplodedEndpointWrapper<T::PropertyBuilder>;
+    type MetadataBuilder = ExplodedEndpointWrapper<T::MetadataBuilder>;
 
     fn entity(&self) -> Self::Entity {
         self.inner.entity()
     }
+
+    fn property_builder(
+        &self,
+        builder: PropertyFilterBuilder<Self::Entity>,
+    ) -> Self::PropertyBuilder {
+        self.wrap(self.inner.property_builder(builder))
+    }
+
+    fn metadata_builder(
+        &self,
+        builder: MetadataFilterBuilder<Self::Entity>,
+    ) -> Self::MetadataBuilder {
+        self.wrap(self.inner.metadata_builder(builder))
+    }
 }
 
 impl<T: TemporalPropertyFilterFactory> TemporalPropertyFilterFactory