Graphql refactor + rolling/expanding

Cargo.toml

@@ -42,9 +42,9 @@ debug = 0
 pometry-storage = { version = ">=0.8.1", path = "pometry-storage" }
 #[private-storage]
 # pometry-storage = { path = "pometry-storage-private", package = "pometry-storage-private" }
-async-graphql = { version = "7.0.13", features = ["dynamic-schema"] }
+async-graphql = { version = "7.0.16", features = ["dynamic-schema"] }
 bincode = "1.3.3"
-async-graphql-poem = "7.0.13"
+async-graphql-poem = "7.0.16"
 dynamic-graphql = "0.10.1"
 reqwest = { version = "0.12.8", default-features = false, features = [
     "rustls-tls",

python/python/raphtory/__init__.pyi

@@ -113,6 +113,14 @@ class GraphView(object):
     def create_index(self):
         """Create graph index"""
 
+    def create_index_in_ram(self):
+        """
+        Creates a graph index in memory (RAM).
+
+        This is primarily intended for use in tests and should not be used in production environments,
+        as the index will not be persisted to disk.
+        """
+
     def default_layer(self) -> GraphView:
         """
          Return a view of GraphView containing only the default edge layer
@@ -257,18 +265,6 @@ class GraphView(object):
             GraphView: The filtered view
         """
 
-    def filter_exploded_edges(self, filter: PropertyFilter) -> GraphView:
-        """
-        Return a filtered view that only includes exploded edges that satisfy the filter
-
-        Arguments:
-            filter (PropertyFilter): The filter to apply to the exploded edge properties. Construct a
-                                     filter using `Prop`.
-
-        Returns:
-            GraphView: The filtered view
-        """
-
     def filter_nodes(self, filter: PropertyFilter) -> GraphView:
         """
         Return a filtered view that only includes nodes that satisfy the filter
@@ -2323,18 +2319,6 @@ class Node(object):
             Node: The filtered view
         """
 
-    def filter_exploded_edges(self, filter: PropertyFilter) -> Node:
-        """
-        Return a filtered view that only includes exploded edges that satisfy the filter
-
-        Arguments:
-            filter (PropertyFilter): The filter to apply to the exploded edge properties. Construct a
-                                     filter using `Prop`.
-
-        Returns:
-            Node: The filtered view
-        """
-
     def filter_nodes(self, filter: PropertyFilter) -> Node:
         """
         Return a filtered view that only includes nodes that satisfy the filter
@@ -2865,18 +2849,6 @@ class Nodes(object):
             Nodes: The filtered view
         """
 
-    def filter_exploded_edges(self, filter: PropertyFilter) -> Nodes:
-        """
-        Return a filtered view that only includes exploded edges that satisfy the filter
-
-        Arguments:
-            filter (PropertyFilter): The filter to apply to the exploded edge properties. Construct a
-                                     filter using `Prop`.
-
-        Returns:
-            Nodes: The filtered view
-        """
-
     def filter_nodes(self, filter: PropertyFilter) -> Nodes:
         """
         Return a filtered view that only includes nodes that satisfy the filter
@@ -3387,18 +3359,6 @@ class PathFromNode(object):
             PathFromNode: The filtered view
         """
 
-    def filter_exploded_edges(self, filter: PropertyFilter) -> PathFromNode:
-        """
-        Return a filtered view that only includes exploded edges that satisfy the filter
-
-        Arguments:
-            filter (PropertyFilter): The filter to apply to the exploded edge properties. Construct a
-                                     filter using `Prop`.
-
-        Returns:
-            PathFromNode: The filtered view
-        """
-
     def filter_nodes(self, filter: PropertyFilter) -> PathFromNode:
         """
         Return a filtered view that only includes nodes that satisfy the filter
@@ -3832,18 +3792,6 @@ class PathFromGraph(object):
             PathFromGraph: The filtered view
         """
 
-    def filter_exploded_edges(self, filter: PropertyFilter) -> PathFromGraph:
-        """
-        Return a filtered view that only includes exploded edges that satisfy the filter
-
-        Arguments:
-            filter (PropertyFilter): The filter to apply to the exploded edge properties. Construct a
-                                     filter using `Prop`.
-
-        Returns:
-            PathFromGraph: The filtered view
-        """
-
     def filter_nodes(self, filter: PropertyFilter) -> PathFromGraph:
         """
         Return a filtered view that only includes nodes that satisfy the filter
@@ -6029,7 +5977,15 @@ class Prop(object):
     def __new__(cls, name: str) -> Prop:
         """Create and return a new object.  See help(type) for accurate signature."""
 
-    def any(self, values: set[PropValue]) -> PropertyFilter:
+    def contains(self, value) -> PropertyFilter:
+        """
+        Create a filter that keeps entities that contains the property
+
+        Returns:
+            PropertyFilter: the property filter
+        """
+
+    def is_in(self, values: set[PropValue]) -> PropertyFilter:
         """
         Create a filter that keeps entities if their property value is in the set
 
@@ -6048,6 +6004,18 @@ class Prop(object):
             PropertyFilter: the property filter
         """
 
+    def is_not_in(self, values: set[PropValue]) -> PropertyFilter:
+        """
+        Create a filter that keeps entities if their property value is not in the set or
+        if they don't have the property
+
+        Arguments:
+            values (set[PropValue]): the set of values to exclude
+
+        Returns:
+            PropertyFilter: the property filter
+        """
+
     def is_some(self) -> PropertyFilter:
         """
         Create a filter that only keeps entities if they have the property
@@ -6056,13 +6024,9 @@ class Prop(object):
             PropertyFilter: the property filter
         """
 
-    def not_any(self, values: set[PropValue]) -> PropertyFilter:
+    def not_contains(self, value) -> PropertyFilter:
         """
-        Create a filter that keeps entities if their property value is not in the set or
-        if they don't have the property
-
-        Arguments:
-            values (set[PropValue]): the set of values to exclude
+        Create a filter that keeps entities that do not contain the property
 
         Returns:
             PropertyFilter: the property filter

python/python/raphtory/filter/__init__.pyi

@@ -19,3 +19,5 @@ from pandas import DataFrame
 from os import PathLike
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
+
+def Property(name): ...

python/python/raphtory/node_state/__init__.pyi

@@ -6847,3 +6847,91 @@ class NodeLayout(object):
         Returns:
              Iterator[list[float]]: Iterator over values
         """
+
+class NodeStateF64String(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __getitem__(self, key):
+        """Return self[key]."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def get(
+        self, node: NodeInput, default: Optional[Tuple[float, str]] = None
+    ) -> Optional[Tuple[float, str]]:
+        """
+        Get value for node
+
+        Arguments:
+            node (NodeInput): the node
+            default (Optional[Tuple[float, str]]): the default value. Defaults to None.
+
+        Returns:
+            Optional[Tuple[float, str]]: the value for the node or the default value
+        """
+
+    def items(self) -> Iterator[Tuple[Node, Tuple[float, str]]]:
+        """
+        Iterate over items
+
+        Returns:
+             Iterator[Tuple[Node, Tuple[float, str]]]: Iterator over items
+        """
+
+    def nodes(self) -> Nodes:
+        """
+        Iterate over nodes
+
+        Returns:
+            Nodes: The nodes
+        """
+
+    def sorted_by_id(self) -> NodeStateF64String:
+        """
+        Sort results by node id
+
+        Returns:
+             NodeStateF64String: The sorted node state
+        """
+
+    def to_df(self) -> DataFrame:
+        """
+        Convert results to pandas DataFrame
+
+        The DataFrame has two columns, "node" with the node ids and "value" with
+        the corresponding values.
+
+        Returns:
+            DataFrame: the pandas DataFrame
+        """
+
+    def values(self) -> Iterator[Tuple[float, str]]:
+        """
+        Iterate over values
+
+        Returns:
+             Iterator[Tuple[float, str]]: Iterator over values
+        """

python/test_utils/filters_setup.py

@@ -10,22 +10,28 @@ def func(graph):
         for initializer in initializers:
             graph = initializer(graph)
         return graph
+
     return func
 
 
 def init_graph(graph):
     nodes = [
-         (1, 1, {"p1": "shivam_kapoor", "p9": 5, "p10": "Paper_airplane"}, "fire_nation"),
-         (2, 2, {"p1": "prop12", "p2": 2, "p10": "Paper_ship"}, "air_nomads"),
-         (3, 1, {"p1": "shivam_kapoor", "p9": 5}, "fire_nation"),
-         (3, 3, {"p2": 6, "p3": 1, "p10": "Paper_airplane"}, "fire_nation"),
-         (4, 1, {"p1": "shivam_kapoor", "p9": 5}, "fire_nation"),
-         (3, 4, {"p4": "pometry"}, None),
-         (4, 4, {"p5": 12}, None),
+        (
+            1,
+            1,
+            {"p1": "shivam_kapoor", "p9": 5, "p10": "Paper_airplane"},
+            "fire_nation",
+        ),
+        (2, 2, {"p1": "prop12", "p2": 2, "p10": "Paper_ship"}, "air_nomads"),
+        (3, 1, {"p1": "shivam_kapoor", "p9": 5}, "fire_nation"),
+        (3, 3, {"p2": 6, "p3": 1, "p10": "Paper_airplane"}, "fire_nation"),
+        (4, 1, {"p1": "shivam_kapoor", "p9": 5}, "fire_nation"),
+        (3, 4, {"p4": "pometry"}, None),
+        (4, 4, {"p5": 12}, None),
     ]
 
     for time, id, props, node_type in nodes:
-            graph.add_node(time, str(id), props, node_type)
+        graph.add_node(time, str(id), props, node_type)
 
     edge_data = [
         (1, "1", "2", {"p1": "shivam_kapoor", "p10": "Paper_airplane"}, "fire_nation"),
@@ -42,6 +48,7 @@ def init_graph(graph):
 
     return graph
 
+
 def init_nodes_graph(graph):
     nodes = [
         (6, "N1", {"p1": 2}),
@@ -137,6 +144,7 @@ def init_nodes_graph(graph):
 
     return graph
 
+
 # For this graph there won't be any temporal property index for property name "p1".
 def init_nodes_graph1(graph):
     nodes = [
@@ -157,17 +165,15 @@ def init_nodes_graph1(graph):
 
     return graph
 
+
 # For this graph there won't be any constant property index for property name "p1".
 def init_nodes_graph2(graph):
     nodes = [
         (1, "N1", {"p1": 1}),
-
         (2, "N2", {"p1": 1}),
         (3, "N2", {"p1": 2}),
-
         (2, "N3", {"p1": 2}),
         (3, "N3", {"p1": 1}),
-
         (2, "N4", {}),
     ]
 
@@ -259,13 +265,13 @@ def init_edges_graph1(graph):
 # For this graph there won't be any constant property index for property name "p1".
 def init_edges_graph2(graph):
     edges = [
-            (2, "N1", "N2", {"p1": 1}),
-            (2, "N2", "N3", {"p1": 1}),
-            (2, "N2", "N3", {"p1": 2}),
-            (2, "N3", "N4", {"p1": 2}),
-            (2, "N3", "N4", {"p1": 1}),
-            (2, "N4", "N5", {}),
-        ]
+        (2, "N1", "N2", {"p1": 1}),
+        (2, "N2", "N3", {"p1": 1}),
+        (2, "N2", "N3", {"p1": 2}),
+        (2, "N3", "N4", {"p1": 2}),
+        (2, "N3", "N4", {"p1": 1}),
+        (2, "N4", "N5", {}),
+    ]
 
     for time, src, dst, props in edges:
         graph.add_edge(time, src, dst, props)