def create_friends(r: Redis): g = Graph('friends', r) adam = Node(label='User', properties={'name': 'Adam', 'mail': 'f****r'}) pernilla = Node(label='User', properties={'name': 'Pernilla'}) david = Node(label='User', properties={'name': 'David'}) g.add_node(adam) g.add_node(pernilla) g.add_node(david) g.add_edge(Edge(adam, 'FRIEND', pernilla)) g.add_edge(Edge(pernilla, 'FRIEND', david)) g.commit() return g
def generate_redisgraph_integration_data(client): """Create Redisgraph test DB from the standard integration data.""" vertex_values, edge_values, _ = get_integration_data() client.query("create (n)") client.query("match (n) delete n") uuid_to_node = {} for vertex_name, vertices in six.iteritems(vertex_values): for vertex_props in vertices: # NOTE(bojanserafimov): Dates and datetimes are not supported in redisgraph, # so we just omit them from the dataset. uuid_to_node[vertex_props["uuid"]] = Node( label=vertex_name, properties={ key: value for key, value in six.iteritems(vertex_props) if not isinstance(value, (datetime.date, datetime.datetime)) }, ) client.add_node(uuid_to_node[vertex_props["uuid"]]) for edge_name, edges in six.iteritems(edge_values): for edge_spec in edges: client.add_edge( Edge( uuid_to_node[edge_spec["from_uuid"]], edge_name, uuid_to_node[edge_spec["to_uuid"]], ) ) client.commit()
def new_node(self): return Node(label = labels[node_ctr % 2], properties = {'unique': node_ctr, 'group': random.choice(groups), 'doubleval': round(random.uniform(-1, 1), 2), 'intval': random.randint(1, 10000), 'stringval': ''.join(random.choice(string.lowercase) for x in range(6))})
def populate_graph(self): global graph nodes = {} # Create entities for idx, p in enumerate(people): node = Node(label="person", properties={"name": p, "val": idx}) graph.add_node(node) nodes[p] = node # Fully connected graph for src in nodes: for dest in nodes: if src != dest: edge = Edge(nodes[src], "know", nodes[dest]) graph.add_edge(edge) for src in nodes: for dest in nodes: if src != dest: edge = Edge(nodes[src], "works_with", nodes[dest]) graph.add_edge(edge) graph.commit() query = """MATCH (a)-[:know]->(b) CREATE (a)-[:know]->(b)""" graph.query(query)
def test06_replace_property_map(self): empty_node = Node() result = graph.query("MATCH (n) SET n = {} RETURN n") expected_result = [[empty_node]] # The node originally had 2 properties, 'name' and 'city_name' self.env.assertEqual(result.properties_set, 2) self.env.assertEqual(result.result_set, expected_result)
def populate_graph(self): global redis_graph # Construct a graph with the form: # (v1)-[e1]->(v2)-[e2]->(v3) node_props = ['v1', 'v2', 'v3'] nodes = [] for idx, v in enumerate(node_props): node = Node(label="L", properties={"val": v}) nodes.append(node) redis_graph.add_node(node) edge = Edge(nodes[0], "E", nodes[1], properties={"edge_val": ['v1', 'v2']}) redis_graph.add_edge(edge) edge = Edge(nodes[1], "E", nodes[2], properties={"edge_val": ['v2', 'v3']}) redis_graph.add_edge(edge) redis_graph.commit()
def populate_graph(self): # Construct a graph with the form: # (v1)-[:E]->(v2)-[:E]->(v3)-[:E]->(v4), (v1)-[:E]->(v5)-[:E2]->(v4) global nodes for v in range(1, 6): node = Node(label="L", properties={"v": v}) nodes.append(node) redis_graph.add_node(node) edge = Edge(nodes[0], "E", nodes[1]) redis_graph.add_edge(edge) edge = Edge(nodes[1], "E", nodes[2]) redis_graph.add_edge(edge) edge = Edge(nodes[2], "E", nodes[3]) redis_graph.add_edge(edge) edge = Edge(nodes[0], "E", nodes[4]) redis_graph.add_edge(edge) edge = Edge(nodes[4], "E2", nodes[3]) redis_graph.add_edge(edge) redis_graph.commit()
def test08_multiple_updates_to_property_map(self): node = Node(properties={"v": 1, "v2": 2, "v4": 4}) result = graph.query( "MATCH (n) SET n.v3 = 3, n = {v: 1}, n += {v2: 2}, n.v4 = 4 RETURN n" ) expected_result = [[node]] self.env.assertEqual(result.result_set, expected_result)
def test01_negated_simple_path_filter(self): node0 = Node(node_id=0, label="L") node1 = Node(node_id=1, label="L", properties={'x': 1}) edge01 = Edge(src_node=node0, dest_node=node1, relation="R") redis_graph.add_node(node0) redis_graph.add_node(node1) redis_graph.add_edge(edge01) redis_graph.flush() query = "MATCH(n:L) WHERE NOT (n)-[:R]->(:L) RETURN n" result_set = redis_graph.query(query) expected_results = [[node1]] query_info = QueryInfo(query=query, description="Tests simple negated path filter", expected_result=expected_results) self._assert_resultset_equals_expected(result_set, query_info)
def test_array_functions(self): redis_graph = Graph('social', self.r) query = """CREATE (p:person{name:'a',age:32, array:[0,1,2]})""" redis_graph.query(query) query = """WITH [0,1,2] as x return x""" result = redis_graph.query(query) self.assertEqual([0, 1, 2], result.result_set[0][0]) query = """MATCH(n) return collect(n)""" result = redis_graph.query(query) a = Node(node_id=0, label='person', properties={ 'name': 'a', 'age': 32, 'array': [0, 1, 2] }) self.assertEqual([a], result.result_set[0][0]) # All done, remove graph. redis_graph.delete()
def test14_post_deletion_traversal_directions(self): self.env.flush() redis_con = self.env.getConnection() redis_graph = Graph("G", redis_con) nodes = {} # Create entities. labels = ["Dest", "Src", "Src2"] for idx, l in enumerate(labels): node = Node(label=l, properties={"val": idx}) redis_graph.add_node(node) nodes[l] = node edge = Edge(nodes["Src"], "R", nodes["Dest"]) redis_graph.add_edge(edge) edge = Edge(nodes["Src2"], "R", nodes["Dest"]) redis_graph.add_edge(edge) redis_graph.commit() # Delete a node. query = """MATCH (n:Src2) DELETE n""" actual_result = redis_graph.query(query) self.env.assertEquals(actual_result.nodes_deleted, 1) self.env.assertEquals(actual_result.relationships_deleted, 1) query = """MATCH (n1:Src)-[*]->(n2:Dest) RETURN COUNT(*)""" actual_result = redis_graph.query(query) expected_result = [[1]] self.env.assertEquals(actual_result.result_set, expected_result) # Perform the same traversal, this time traveling from destination to source. query = """MATCH (n1:Src)-[*]->(n2:Dest {val: 0}) RETURN COUNT(*)""" actual_result = redis_graph.query(query) expected_result = [[1]] self.env.assertEquals(actual_result.result_set, expected_result)
def populate_graph(self, graph_name): people = ["Roi", "Alon", "Ailon", "Boaz", "Tal", "Omri", "Ori"] countries = ["Israel", "USA", "Japan", "United Kingdom"] visits = [("Roi", "USA"), ("Alon", "Israel"), ("Ailon", "Japan"), ("Boaz", "United Kingdom")] redis_graph = Graph(graph_name, redis_con) if not redis_con.exists(graph_name): personNodes = {} countryNodes = {} # Create entities for p in people: person = Node(label="person", properties={"name": p}) redis_graph.add_node(person) personNodes[p] = person for p in countries: country = Node(label="country", properties={"name": p}) redis_graph.add_node(country) countryNodes[p] = country for v in visits: person = v[0] country = v[1] edge = Edge(personNodes[person], 'visit', countryNodes[country], properties={'purpose': 'pleasure'}) redis_graph.add_edge(edge) redis_graph.commit() # Delete nodes, to introduce deleted item within our datablock query = """MATCH (n:person) WHERE n.name = 'Roi' or n.name = 'Ailon' DELETE n""" redis_graph.query(query) query = """MATCH (n:country) WHERE n.name = 'USA' DELETE n""" redis_graph.query(query) # Create index. actual_result = redis_con.execute_command( "GRAPH.QUERY", graph_name, "CREATE INDEX ON :person(name)") actual_result = redis_con.execute_command( "GRAPH.QUERY", graph_name, "CREATE INDEX ON :country(name)") return redis_graph
def test00_test_data_valid_after_rename(self): global graph node0 = Node(node_id=0, label="L", properties={'name':'x', 'age':1}) graph.add_node(node0) graph.flush() redis_con.rename(GRAPH_ID, NEW_GRAPH_ID) graph = Graph(NEW_GRAPH_ID, redis_con) node1 = Node(node_id=0, label="L", properties={'name':'x', 'age':1}) graph.add_node(node1) graph.flush() query = "MATCH (n) return n" expected_results = [[node0], [node1]] query_info = QueryInfo(query = query, description="Tests data is valid after renaming", expected_result = expected_results) self._assert_resultset_and_expected_mutually_included(graph.query(query), query_info)
def populate_graph(self): global redis_graph node_props = [(622, "Mo"), (819, "Bing"), (819, "Qiu")] for idx, v in enumerate(node_props): node = Node(label="Person", properties={"id": v[0], "name": v[1]}) redis_graph.add_node(node) redis_graph.commit()
def test_v6_decode(self): graph_name = "v6_rdb_restore" # dump created with the following query (v6 supported property value: integer, double, boolean, string, null, array) # graph.query g "CREATE (:L1 {val:1, strval: 'str', numval: 5.5, nullval: NULL, boolval: true, array: [1,2,3]})-[:E{val:2}]->(:L2{val:3})" # graph.query g "CREATE INDEX ON :L1(val)" # dump g v6_rdb = b"\a\x81\x82\xb6\xa9\x85\xd6\xadh\x06\x05\x02g\x00\x02\x06\x05\x04val\x00\x05\astrval\x00\x05\anumval\x00\x05\bnullval\x00\x05\bboolval\x00\x05\x06array\x00\x02\x02\x02\x00\x05\x03L1\x00\x02\x01\x02\x00\x05\x04val\x00\x02\x01\x05\x03L2\x00\x02\x00\x02\x01\x02\x00\x05\x02E\x00\x02\x00\x02\x02\x02\x01\x02\x00\x02\x06\x05\x04val\x00\x02`\x00\x02\x01\x05\astrval\x00\x02H\x00\x05\x04str\x00\x05\anumval\x00\x02\x80\x00\x00@\x00\x04\x00\x00\x00\x00\x00\x00\x16@\x05\bnullval\x00\x02\x80\x00\x00\x80\x00\x05\bboolval\x00\x02P\x00\x02\x01\x05\x06array\x00\x02\b\x02\x03\x02`\x00\x02\x01\x02`\x00\x02\x02\x02`\x00\x02\x03\x02\x01\x02\x01\x02\x01\x05\x04val\x00\x02`\x00\x02\x03\x02\x01\x02\x00\x02\x01\x02\x00\x02\x01\x05\x04val\x00\x02`\x00\x02\x02\x00\t\x00\xd9\r\xb4c\xf2Z\xd9\xb3" redis_con.restore(graph_name, 0, v6_rdb, True) redis_graph = Graph(graph_name, redis_con) node0 = Node(node_id=0, label='L1', properties={'val': 1, 'strval': 'str', 'numval': 5.5, 'boolval': True, 'array': [1,2,3]}) node1 = Node(node_id=1, label='L2', properties={'val': 3}) edge01 = Edge(src_node=0, relation='E', dest_node=1, edge_id=0, properties={'val':2}) results = redis_graph.query("MATCH (n)-[e]->(m) RETURN n, e, m") self.env.assertEqual(results.result_set, [[node0, edge01, node1]]) plan = redis_graph.execution_plan("MATCH (n:L1 {val:1}) RETURN n") self.env.assertIn("Index Scan", plan) results = redis_graph.query("MATCH (n:L1 {val:1}) RETURN n") self.env.assertEqual(results.result_set, [[node0]])
def test07_test_edge_filters(self): node0 = Node(node_id=0, label="L") node1 = Node(node_id=1, label="L") node2 = Node(node_id=2, label="L") edge01 = Edge(src_node=node0, dest_node=node1, relation="R", properties={'x':1}) edge12 = Edge(src_node=node1, dest_node=node2, relation="R") redis_graph.add_node(node0) redis_graph.add_node(node1) redis_graph.add_node(node2) redis_graph.add_edge(edge01) redis_graph.add_edge(edge12) redis_graph.flush() query = "MATCH (n:L) WHERE (n)-[:R {x:1}]->() RETURN n" result_set = redis_graph.query(query) expected_results = [[node0]] query_info = QueryInfo(query = query, description="Tests pattern filter edge conditions", expected_result = expected_results) self._assert_resultset_and_expected_mutually_included(result_set, query_info)
def create_artist_node(self): if self.current_artist_present(): return False else: artist_node = Node(label='artist', properties={'name': self.artist}) self.graph.add_node(artist_node) self.graph.commit() return True
def populate_graph(self): # Populate a graph with two labels, each containing the same property values but different keys. # Each node pair is connected by an edge from label_a to label_b a_nodes = [] for idx, v in enumerate(values): node = Node(label="label_a", properties={"a_val": v, "a_idx": idx}) a_nodes.append(node) redis_graph.add_node(node) for idx, v in enumerate(values): node = Node(label="label_b", properties={"b_val": v, "b_idx": idx}) redis_graph.add_node(node) edge = Edge(a_nodes[idx], 'connects', node, properties={"edgeval": idx}) redis_graph.add_edge(edge) redis_graph.commit()
def test_node_retrival(self): p0 = Node(node_id=0, label="Person", properties={'name': 'a'}) p1 = Node(node_id=1, label="Person", properties={'name': 'b'}) p2 = Node(node_id=2, label="NoPerson", properties={'name': 'a'}) redis_graph.add_node(p0) redis_graph.add_node(p1) redis_graph.add_node(p2) redis_graph.flush() params = {'name': 'a'} query = "MATCH (n :Person {name:$name}) RETURN n" expected_results = [[p0]] query_info = QueryInfo(query=query, description="Tests expression on param", expected_result=expected_results) self._assert_resultset_equals_expected( redis_graph.query(query, params), query_info)
def test_v4_decode(self): graph_name = "v4_rdb_restore" # dump created with the following query (v4 supported property value: integer, double, boolean, string) # graph.query g "CREATE (:L1 {val:1, strval: 'str', doubleval: 5.5, boolval: true})-[:E{val:2}]->(:L2{val:3})" # graph.query g "CREATE INDEX ON :L1(val)" # dump g v4_rdb = b"\a\x81\x82\xb6\xa9\x85\xd6\xadh\x04\x05\x02g\x00\x02\x02\x02\x81\xff\xff\xff\xff\xff\xff\xff\xff\x05\x04ALL\x00\x02\x04\x05\aboolval\x05\tdoubleval\x05\x06strval\x05\x03val\x02\x00\x05\x03L1\x00\x02\x04\x05\aboolval\x05\tdoubleval\x05\x06strval\x05\x03val\x02\x01\x05\x03L2\x00\x02\x01\x05\x03val\x02\x01\x02\x81\xff\xff\xff\xff\xff\xff\xff\xff\x05\x04ALL\x00\x02\x01\x05\x03val\x02\x00\x05\x02E\x00\x02\x01\x05\x03val\x02\x02\x02\x00\x02\x01\x02\x00\x02\x04\x05\bboolval\x00\x02\x10\x02\x01\x05\ndoubleval\x00\x02@@\x04\x00\x00\x00\x00\x00\x00\x16@\x05\astrval\x00\x02A\x00\x05\x04str\x00\x05\x04val\x00\x02\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x04val\x00\x02\x04\x02\x03\x02\x01\x02\x00\x02\x00\x02\x01\x02\x00\x02\x01\x05\x04val\x00\x02\x04\x02\x02\x02\x01\x05\x03L1\x00\x05\x04val\x00\x00\t\x00\xb38\x87\x01U^\x8b\xe3" redis_con.restore(graph_name, 0, v4_rdb, True) redis_graph = Graph(graph_name, redis_con) node0 = Node(node_id=0, label='L1', properties={'val':1, 'strval': 'str', 'doubleval': 5.5, 'boolval': True}) node1 = Node(node_id=1, label='L2', properties={'val':3}) edge01 = Edge(src_node=0, relation='E', dest_node=1, edge_id=0, properties={'val':2}) results = redis_graph.query("MATCH (n)-[e]->(m) RETURN n, e, m") self.env.assertEqual(results.result_set, [[node0, edge01, node1]]) plan = redis_graph.execution_plan("MATCH (n:L1 {val:1}) RETURN n") self.env.assertIn("Index Scan", plan) results = redis_graph.query("MATCH (n:L1 {val:1}) RETURN n") self.env.assertEqual(results.result_set, [[node0]])
def test06_test_level_2_nesting_logical_operators_over_path_filters(self): node0 = Node(node_id=0, label="L") node1 = Node(node_id=1, label="L", properties={'x':1}) node2 = Node(node_id=2, label="L2") edge01 = Edge(src_node=node0, dest_node=node1, relation="R") edge12 = Edge(src_node=node1, dest_node=node2, relation="R2") redis_graph.add_node(node0) redis_graph.add_node(node1) redis_graph.add_node(node2) redis_graph.add_edge(edge01) redis_graph.add_edge(edge12) redis_graph.flush() query = "MATCH (n:L) WHERE (n)-[:R]->(:L) OR (n.x=1 AND ((n)-[:R2]->(:L2) OR (n)-[:R]->(:L))) RETURN n" result_set = redis_graph.query(query) expected_results = [[node0],[node1]] query_info = QueryInfo(query = query, description="Tests AND condition with simple filter and nested OR", expected_result = expected_results) self._assert_resultset_and_expected_mutually_included(result_set, query_info)
def test03_path_filter_or_negated_path_filter(self): node0 = Node(node_id=0, label="L") node1 = Node(node_id=1, label="L", properties={'x': 1}) edge01 = Edge(src_node=node0, dest_node=node1, relation="R") redis_graph.add_node(node0) redis_graph.add_node(node1) redis_graph.add_edge(edge01) redis_graph.flush() query = "MATCH(n:L) WHERE (n)-[:R]->(:L) OR NOT (n)-[:R]->(:L) RETURN n" result_set = redis_graph.query(query) expected_results = [[node0], [node1]] query_info = QueryInfo( query=query, description="Tests OR condition with path and negated path filters", expected_result=expected_results) self._assert_resultset_and_expected_mutually_included( result_set, query_info)
def model_to_node(self, instance: NodeModel, auto_add=False): node = Node(alias=instance.get_alias(), label=instance.get_labels()[0], properties=instance.get_properties(), node_id=instance.get_id()) self.model_to_node_dict[instance] = node if auto_add and self.graph: self.graph.add_node(node) return node
def test_path_comparison(self): node0 = Node(node_id=0, label="L1") node1 = Node(node_id=1, label="L1") node2 = Node(node_id=2, label="L1") edge01 = Edge(node0, "R1", node1, edge_id=0, properties={'value': 1}) edge12 = Edge(node1, "R1", node2, edge_id=1, properties={'value': 2}) redis_graph.add_node(node0) redis_graph.add_node(node1) redis_graph.add_node(node2) redis_graph.add_edge(edge01) redis_graph.add_edge(edge12) redis_graph.flush() # Rewrite the edges with IDs instead of node values to match how they are returned. edge01 = Edge(0, "R1", 1, edge_id=0, properties={'value': 1}) edge12 = Edge(1, "R1", 2, edge_id=1, properties={'value': 2}) path01 = Path.new_empty_path().add_node(node0).add_edge( edge01).add_node(node1) path12 = Path.new_empty_path().add_node(node1).add_edge( edge12).add_node(node2) # Test a path equality filter query = "MATCH p1 = (:L1)-[:R1]->(:L1) MATCH p2 = (:L1)-[:R1]->(:L1) WHERE p1 = p2 RETURN p1" expected_results = [[path01], [path12]] query_info = QueryInfo(query=query, description="Test path equality", expected_result=expected_results) self._assert_resultset_and_expected_mutually_included( redis_graph.query(query), query_info) # Test a path inequality filter query = "MATCH p1 = (:L1)-[:R1]->(:L1) MATCH p2 = (:L1)-[:R1]->(:L1) WHERE p1 <> p2 RETURN DISTINCT p1, p2" expected_results = [[path01, path12], [path12, path01]] query_info = QueryInfo(query=query, description="Test path inequality", expected_result=expected_results) self._assert_resultset_and_expected_mutually_included( redis_graph.query(query), query_info)
def test_bi_directional_path(self): node0 = Node(node_id=0, label="L1") node1 = Node(node_id=1, label="L1") node2 = Node(node_id=2, label="L1") edge01 = Edge(node0, "R1", node1, edge_id=0, properties={'value': 1}) edge12 = Edge(node1, "R1", node2, edge_id=1, properties={'value': 2}) redis_graph.add_node(node0) redis_graph.add_node(node1) redis_graph.add_node(node2) redis_graph.add_edge(edge01) redis_graph.add_edge(edge12) redis_graph.flush() # Rewrite the edges with IDs instead of node values to match how they are returned. edge01 = Edge(0, "R1", 1, edge_id=0, properties={'value': 1}) edge12 = Edge(1, "R1", 2, edge_id=1, properties={'value': 2}) # Reverse direction edges which are not part of the graph. Read only values. edge10 = Edge(1, "R1", 0, edge_id=0, properties={'value': 1}) edge21 = Edge(2, "R1", 1, edge_id=1, properties={'value': 2}) path010 = Path.new_empty_path().add_node(node0).add_edge( edge01).add_node(node1).add_edge(edge10).add_node(node0) path0121 = Path.new_empty_path().add_node(node0).add_edge(edge01).add_node(node1).add_edge(edge12) \ .add_node(node2).add_edge(edge21).add_node(node1) path01210 = Path.new_empty_path().add_node(node0).add_edge(edge01).add_node(node1).add_edge(edge12) \ .add_node(node2).add_edge(edge21).add_node(node1).add_edge(edge10).add_node(node0) path121 = Path.new_empty_path().add_node(node1).add_edge( edge12).add_node(node2).add_edge(edge21).add_node(node1) path1210 = Path.new_empty_path().add_node(node1).add_edge(edge12).add_node(node2).add_edge(edge21) \ .add_node(node1).add_edge(edge10).add_node(node0) expected_results = [[path010], [path0121], [path01210], [path121], [path1210]] query = "MATCH p=(:L1)-[:R1*]->(:L1)<-[:R1*]-() RETURN p" query_info = QueryInfo( query=query, description="Tests bi directional variable length paths", expected_result=expected_results) self._assert_resultset_and_expected_mutually_included( redis_graph.query(query), query_info)
def test_zero_length_path(self): node0 = Node(node_id=0, label="L1") node1 = Node(node_id=1, label="L2") edge01 = Edge(node0, "R1", node1, edge_id=0, properties={'value': 1}) redis_graph.add_node(node0) redis_graph.add_node(node1) redis_graph.add_edge(edge01) redis_graph.flush() path01 = Path.new_empty_path().add_node(node0).add_edge(edge01).add_node(node1) expected_results=[[path01]] query = "MATCH p=(:L1)-[*0..]->()-[]->(:L2) RETURN p" query_info = QueryInfo(query = query, description="Tests path with zero length variable length paths", \ expected_result = expected_results) self._assert_resultset_and_expected_mutually_included(redis_graph.query(query), query_info)
def test_node(self): pool = RedisPool(urls=("localhost", 6379)) graph = pool.graph("test") john = Node(label='person', properties={ 'name': 'John Doe', 'age': 33, 'gender': 'male', 'status': 'single' }) graph.add_node(john) japan = Node(label='country', properties={'name': 'Japan'}) graph.add_node(japan) edge = Edge(john, 'visited', japan, properties={'purpose': 'pleasure'}) graph.add_edge(edge) graph.commit()
def populate_graph(self): # Construct a graph with the form: # (a:A)-[:E]->(b:B), (c:C)-[:E]->(b) a = Node(label="A", properties={"v": 1}) graph.add_node(a) b = Node(label="B", properties={"v": 2}) graph.add_node(b) c = Node(label="C", properties={"v": 3}) graph.add_node(c) edge = Edge(a, "E", b) graph.add_edge(edge) edge = Edge(c, "E", b) graph.add_edge(edge) graph.commit()
def test01_collect(self): for i in range(10): redis_graph.add_node(Node()) redis_graph.commit() query = """MATCH (n) RETURN collect(n)""" result = redis_graph.query(query) result_set = result.result_set self.env.assertEquals(len(result_set), 1) self.env.assertTrue(all(isinstance(n, Node) for n in result_set[0][0]))
def dump_data(n_records): r = redis.Redis(host='localhost', port=6379) data = data_gen(n_records) redis_graph = Graph('file_activity1', r) nodes = {} edges = {} pprint(data) for rec in data: _node = Node(label='file', properties={ 'fid': rec['_id'], 'name': rec['name'], 'date_added': rec['date_added'], 'platform': rec['platform'] }) r.set(rec['_id'], _node.alias) redis_graph.add_node(_node) nodes[rec['_id']] = _node for rec in data: for fileid, time_stamp in rec['downloaded']: edge = Edge(nodes[rec['_id']], 'DOWNLOADED', nodes[fileid], properties={ 'time': time_stamp, 'activity': 'downloaded' }) redis_graph.add_edge(edge) for fileid, time_stamp in rec['executed']: edge = Edge(nodes[rec['_id']], 'EXECUTED', nodes[fileid], properties={ 'time': time_stamp, 'activity': 'executed' }) redis_graph.add_edge(edge) for fileid, time_stamp in rec['removed']: edge = Edge(nodes[rec['_id']], 'REMOVED', nodes[fileid], properties={ 'time': time_stamp, 'activity': 'removed' }) redis_graph.add_edge(edge) redis_graph.commit() print("Graph created")