raphtory 0.17.0

raphtory, a temporal graph library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use itertools::Itertools;
use raphtory::{prelude::*, test_storage, test_utils::test_graph};
use raphtory_api::core::storage::{arc_str::ArcStr, timeindex::AsTime};
use std::collections::HashMap;

#[test]
fn test_properties() {
    let graph = Graph::new();
    let props = [(ArcStr::from("test"), "test".into_prop())];
    graph.add_edge(0, 1, 2, NO_PROPS, None).unwrap();
    graph.add_edge(2, 1, 2, props.clone(), None).unwrap();
    test_storage!(&graph, |graph| {
        let e1 = graph.edge(1, 2).unwrap();
        let e1_w = graph.window(0, 1).edge(1, 2).unwrap();
        assert_eq!(
            HashMap::from_iter(e1.properties().as_vec()),
            props.clone().into()
        );
        assert!(e1_w.properties().as_vec().is_empty())
    });
}

#[test]
fn test_metadata() {
    let graph = Graph::new();
    graph
        .add_edge(1, 1, 2, NO_PROPS, Some("layer 1"))
        .unwrap()
        .add_metadata([("test_prop", "test_val")], None)
        .unwrap();
    graph
        .add_edge(1, 2, 3, NO_PROPS, Some("layer 2"))
        .unwrap()
        .add_metadata([("test_prop", "test_val"), ("other", "2")], None)
        .unwrap();

    graph
        .add_edge(1, 2, 3, NO_PROPS, Some("layer 3"))
        .unwrap()
        .add_metadata([("test_prop", "test_val"), ("other", "3")], None)
        .unwrap();

    // FIXME: #18 metadata prop for edges
    test_graph(&graph, |graph| {
        assert_eq!(
            graph.edge(1, 2).unwrap().metadata().get("test_prop"),
            Some(Prop::map([("layer 1", "test_val")]))
        );
        assert_eq!(
            graph.edge(2, 3).unwrap().metadata().get("test_prop"),
            Some(Prop::map([
                ("layer 2", "test_val"),
                ("layer 3", "test_val")
            ]))
        );

        assert_eq!(
            graph.edge(2, 3).unwrap().metadata().get("other"),
            Some(Prop::map([("layer 2", "2"), ("layer 3", "3")]))
        );

        assert_eq!(
            graph
                .valid_layers(["layer 3", "layer 2"])
                .edge(2, 3)
                .unwrap()
                .metadata()
                .get("other"),
            Some(Prop::map([("layer 2", "2"), ("layer 3", "3")]))
        );

        for e in graph.edges() {
            for ee in e.explode() {
                assert_eq!(ee.metadata().get("test_prop"), Some("test_val".into()))
            }
        }
    });
}

#[test]
fn test_property_additions() {
    let graph = Graph::new();
    let props = [("test", "test")];
    let e1 = graph.add_edge(0, 1, 2, NO_PROPS, None).unwrap();
    e1.add_updates(2, props, None).unwrap(); // same layer works
    assert!(e1.add_updates(2, props, Some("test2")).is_err()); // different layer is error
    let e = graph.edge(1, 2).unwrap();
    e.add_updates(2, props, Some("test2")).unwrap(); // non-restricted edge view can create new layers
    let layered_views = e.explode_layers().into_iter().collect_vec();
    for ev in layered_views {
        let layer = ev.layer_name().unwrap();
        assert!(ev.add_updates(1, props, Some("test")).is_err()); // restricted edge view cannot create updates in different layer
        ev.add_updates(1, [("test2", layer)], None).unwrap() // this will add an update to the same layer as the view (not the default layer)
    }

    let e1_w = e1.window(0, 1);
    assert_eq!(
        e1.properties().as_map(),
        props
            .into_iter()
            .map(|(k, v)| (ArcStr::from(k), v.into_prop()))
            .chain([(ArcStr::from("test2"), "_default".into_prop())])
            .collect()
    );
    assert_eq!(
        e.layers("test2").unwrap().properties().as_map(),
        props
            .into_iter()
            .map(|(k, v)| (ArcStr::from(k), v.into_prop()))
            .chain([(ArcStr::from("test2"), "test2".into_prop())])
            .collect()
    );
    assert_eq!(e1_w.properties().as_map(), HashMap::default())
}

#[test]
fn test_metadata_additions() {
    let g = Graph::new();
    let e = g.add_edge(0, 1, 2, NO_PROPS, Some("test")).unwrap();
    assert_eq!(e.edge.layer(), Some(0));
    assert!(e.add_metadata([("test1", "test1")], None).is_ok()); // adds properties to layer `"test"`
    assert!(e.add_metadata([("test", "test")], Some("test2")).is_err()); // cannot add properties to a different layer
    e.add_metadata([("test", "test")], Some("test")).unwrap(); // layer is consistent
    assert_eq!(e.metadata().get("test"), Some("test".into()));
    assert_eq!(e.metadata().get("test1"), Some("test1".into()));
}

#[test]
fn test_metadata_updates() {
    let g = Graph::new();
    let e = g.add_edge(0, 1, 2, NO_PROPS, Some("test")).unwrap();
    assert!(e.add_metadata([("test1", "test1")], None).is_ok()); // adds properties to layer `"test"`
    assert!(e.update_metadata([("test1", "test2")], None).is_ok());
    assert_eq!(e.metadata().get("test1"), Some("test2".into()));
}

#[test]
fn test_layers_earliest_time() {
    let g = Graph::new();
    let e = g.add_edge(1, 1, 2, NO_PROPS, Some("test")).unwrap();
    assert_eq!(e.earliest_time().map(|t| t.t()), Some(1));
}