Layers

python/python/raphtory/filter/__init__.pyi

@@ -199,6 +199,10 @@ class Node(object):
     @staticmethod
     def id(): ...
     @staticmethod
+    def layer(layer): ...
+    @staticmethod
+    def layers(layers): ...
+    @staticmethod
     def metadata(name): ...
     @staticmethod
     def name(): ...
@@ -540,6 +544,10 @@ class Edge(object):
     @staticmethod
     def dst(): ...
     @staticmethod
+    def layer(layer): ...
+    @staticmethod
+    def layers(layers): ...
+    @staticmethod
     def metadata(name): ...
     @staticmethod
     def property(name): ...
@@ -883,6 +891,10 @@ class EdgeEndpointTypeFilter(object):
         """
 
 class ExplodedEdge(object):
+    @staticmethod
+    def layer(layer): ...
+    @staticmethod
+    def layers(layers): ...
     @staticmethod
     def metadata(name): ...
     @staticmethod

python/test_utils/utils.py

@@ -182,6 +182,42 @@ def run_group_graphql_error_test(queries_and_expected_error_messages, graph):
             ), f"Expected '{expected_error_message}', but got '{error_message}'"
 
 
+def run_graphql_error_test_contains(query, expected_substrings, graph):
+    tmp_work_dir = tempfile.mkdtemp()
+    with GraphServer(tmp_work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.send_graph(path="g", graph=graph)
+
+        with pytest.raises(Exception) as excinfo:
+            client.query(query)
+
+        full_error_message = str(excinfo.value)
+        match = re.search(r'"message":"(.*?)"', full_error_message)
+        error_message = match.group(1) if match else ""
+
+        for s in expected_substrings:
+            assert s in error_message, f"expected to find {s!r} in {error_message!r}"
+
+
+def run_graphql_compare_test(query_a, query_b, graph):
+    tmp_work_dir = tempfile.mkdtemp()
+    with GraphServer(tmp_work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.send_graph(path="g", graph=graph)
+
+        resp_a = client.query(query_a)
+        resp_b = client.query(query_b)
+
+        dict_a = json.loads(resp_a) if isinstance(resp_a, str) else resp_a
+        dict_b = json.loads(resp_b) if isinstance(resp_b, str) else resp_b
+
+        assert sort_dict_recursive(dict_a) == sort_dict_recursive(dict_b), (
+            f"Query A != Query B\n"
+            f"A={sort_dict_recursive(dict_a)}\n"
+            f"B={sort_dict_recursive(dict_b)}"
+        )
+
+
 def assert_set_eq(left, right):
     """Check if two lists are the same set and same length"""
     assert len(left) == len(right)

python/tests/test_base_install/test_filters/test_edge_property_filter.py

@@ -1436,3 +1436,27 @@ def check(graph):
         }
 
     return check
+
+
+@with_disk_variants(init_graph, variants=("graph", "persistent_graph"))
+def test_filter_edges_temporal_layer_eq():
+    def check(graph):
+        expr = (
+            filter.Edge.layers(["air_nomads"]).property("p10").temporal().last()
+            == "Paper_ship"
+        )
+        assert _pairs(graph.filter(expr).edges) == {("2", "3")}
+
+    return check
+
+
+@with_disk_variants(init_graph, variants=("graph", "persistent_graph"))
+def test_filter_edges_temporal_layer_eq_is_empty():
+    def check(graph):
+        expr = (
+            filter.Edge.layer("air_nomads").property("p10").temporal().last()
+            == "Paper_airplane"
+        )
+        assert _pairs(graph.filter(expr).edges) == set()
+
+    return check

python/tests/test_base_install/test_filters/test_node_property_filter.py

@@ -1139,3 +1139,24 @@ def check(graph):
         assert list(graph.filter(expr).nodes.id) == []
 
     return check
+
+
+@with_disk_variants(create_test_graph, variants=("graph", "persistent_graph"))
+def test_filter_nodes_temporal_layer_sum_ge():
+    def check(graph):
+        expr = (
+            filter.Node.layers(["fire_nation"])
+            .property("prop5")
+            .temporal()
+            .last()
+            .sum()
+            >= 12
+        )
+        msg = """Invalid layer: fire_nation. Valid layers: ["_default"]"""
+        with pytest.raises(
+            Exception,
+            match=re.escape(msg),
+        ):
+            graph.filter(expr).nodes.id
+
+    return check

python/tests/test_base_install/test_graphdb/test_graphdb.py

@@ -1767,15 +1767,15 @@ def check(g):
         with pytest.raises(
             Exception,
             match=re.escape(
-                "Invalid layer: test_layer. Valid layers: _default, layer1, layer2"
+                """Invalid layer: test_layer. Valid layers: ["_default", "layer1", "layer2"]"""
             ),
         ):
             g.layers(["test_layer"])
 
         with pytest.raises(
             Exception,
             match=re.escape(
-                "Invalid layer: test_layer. Valid layers: _default, layer1, layer2"
+                """Invalid layer: test_layer. Valid layers: ["_default", "layer1", "layer2"]"""
             ),
         ):
             g.edge(1, 2).layers(["test_layer"])

python/tests/test_base_install/test_graphql/test_filters/test_graph_edges_property_filter.py

@@ -1,7 +1,12 @@
 import pytest
 from raphtory import Graph, PersistentGraph
 from filters_setup import create_test_graph, init_graph2
-from utils import run_graphql_test, run_graphql_error_test
+from utils import (
+    run_graphql_test,
+    run_graphql_error_test,
+    run_graphql_error_test_contains,
+    run_graphql_compare_test,
+)
 
 EVENT_GRAPH = create_test_graph(Graph())
 PERSISTENT_GRAPH = create_test_graph(PersistentGraph())
@@ -715,3 +720,149 @@ def test_edges_chained_selection_edges_filter_paired_ver2(graph):
         }
     }
     run_graphql_test(query, expected_output, graph)
+
+
+@pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
+def test_edge_temporal_property_filter_empty_layers_is_error(graph):
+    query = """
+    query {
+      graph(path: "g") {
+        filterEdges(expr: {
+          temporalProperty: {
+            name: "prop5"
+            layers: []
+            where: { any: { avg: { lt: { f64: 10.0 } } } }
+          }
+        }) {
+          edges { list { src { name } dst { name } } }
+        }
+      }
+    }
+    """
+
+    run_graphql_error_test_contains(
+        query,
+        [
+            "EdgeFilter.temporalProperty",
+            "'layers' must be non-empty",
+        ],
+        graph,
+    )
+
+
+@pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
+def test_edge_temporal_property_filter_layer_and_layers_is_error(graph):
+    query = """
+    query {
+      graph(path: "g") {
+        filterEdges(expr: {
+          temporalProperty: {
+            name: "prop5"
+            layer: "air_nomads"
+            layers: ["water_tribe"]
+            where: { any: { avg: { lt: { f64: 10.0 } } } }
+          }
+        }) {
+          edges { list { src { name } dst { name } } }
+        }
+      }
+    }
+    """
+
+    run_graphql_error_test_contains(
+        query,
+        [
+            "EdgeFilter.temporalProperty",
+            "either 'layer' or 'layers'",
+            "not both",
+        ],
+        graph,
+    )
+
+
+@pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
+def test_edges_temporal_property_last_with_single_layer(graph):
+    query = """
+    query {
+      graph(path: "g") {
+        filterEdges(expr: {
+          temporalProperty: {
+            name: "p10"
+            layer: "air_nomads"
+            where: { last: { eq: { str: "Paper_ship" } } }
+          }
+        }) {
+          edges { list { src { name } dst { name } } }
+        }
+      }
+    }
+    """
+
+    # Edge (2 -> 3) in air_nomads has p10 Paper_ship at time 2
+    expected = {
+        "graph": {
+            "filterEdges": {
+                "edges": {"list": [{"src": {"name": "2"}, "dst": {"name": "3"}}]}
+            }
+        }
+    }
+
+    run_graphql_test(query, expected, graph)
+
+
+@pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
+def test_edges_temporal_property_last_with_multiple_layers(graph):
+    query = """
+    query {
+      graph(path: "g") {
+        filterEdges(expr: {
+          temporalProperty: {
+            name: "p10"
+            layers: ["fire_nation", "air_nomads"]
+            where: { last: { eq: { str: "Paper_airplane" } } }
+          }
+        }) {
+          edges { list { src { name } dst { name } } }
+        }
+      }
+    }
+    """
+
+    # fire_nation edge (1 -> 2) has p10 Paper_airplane at time 1
+    expected = {
+        "graph": {
+            "filterEdges": {
+                "edges": {"list": [{"src": {"name": "1"}, "dst": {"name": "2"}}]}
+            }
+        }
+    }
+    run_graphql_test(query, expected, graph)
+
+
+@pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
+def test_edges_temporal_property_last_with_default_layer(graph):
+    query = """
+    query {
+      graph(path: "g") {
+        filterEdges(expr: {
+          temporalProperty: {
+            name: "p10"
+            layer: "_default"
+            where: { last: { eq: { str: "Paper_airplane" } } }
+          }
+        }) {
+          edges { list { src { name } dst { name } } }
+        }
+      }
+    }
+    """
+
+    # default-layer edge (2 -> 1) has p10 Paper_airplane at time 3 (edge_type is None)
+    expected = {
+        "graph": {
+            "filterEdges": {
+                "edges": {"list": [{"src": {"name": "2"}, "dst": {"name": "1"}}]}
+            }
+        }
+    }
+    run_graphql_test(query, expected, graph)

python/tests/test_base_install/test_graphql/test_filters/test_nodes_property_filter.py

@@ -7,7 +7,11 @@
     init_graph,
     init_graph2,
 )
-from utils import run_graphql_test, run_graphql_error_test
+from utils import (
+    run_graphql_test,
+    run_graphql_error_test,
+    run_graphql_error_test_contains,
+)
 
 EVENT_GRAPH = create_test_graph(Graph())
 PERSISTENT_GRAPH = create_test_graph(PersistentGraph())
@@ -1051,3 +1055,31 @@ def test_nodes_temporal_property_filter_any_avg_with_window(graph):
         "graph": {"filterNodes": {"nodes": {"list": [{"name": "a"}, {"name": "c"}]}}}
     }
     run_graphql_test(query, expected, graph)
+
+
+@pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
+def test_node_property_layer_filter_not_supported(graph):
+    query = """
+    query {
+      graph(path: "g") {
+        filterNodes(expr: {
+           temporalProperty: {
+            name: "prop5"
+            layer: "air_nomads"
+            where: { any: { avg: { lt: { f64: 10.0 } } } }
+          }
+        }) {
+          nodes {
+            list { name }
+          }
+        }
+      }
+    }
+    """
+
+    expected_needles = [
+        "Invalid layer: air_nomads",
+        "Valid layers:",
+    ]
+
+    run_graphql_error_test_contains(query, expected_needles, graph)

raphtory-api/src/core/entities/layers.rs

@@ -6,7 +6,7 @@ use iter_enum::{
 use rayon::prelude::*;
 use std::{iter::Copied, sync::Arc};
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Layer {
     All,
     None,

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

@@ -54,19 +54,18 @@ pub struct TemporalGraph {
 }
 
 #[derive(Error, Debug)]
-#[error("Invalid layer: {invalid_layer}. Valid layers: {valid_layers}")]
+#[error("Invalid layer: {invalid_layer}. Valid layers: {valid_layers:?}")]
 pub struct InvalidLayer {
     invalid_layer: ArcStr,
-    valid_layers: String,
+    valid_layers: Vec<String>,
 }
 
 #[derive(Error, Debug)]
 #[error("At most {MAX_LAYER} layers are supported.")]
 pub struct TooManyLayers;
 
 impl InvalidLayer {
-    pub fn new(invalid_layer: ArcStr, valid: Vec<String>) -> Self {
-        let valid_layers = valid.join(", ");
+    pub fn new(invalid_layer: ArcStr, valid_layers: Vec<String>) -> Self {
         Self {
             invalid_layer,
             valid_layers,