fixed PR comments

Author: DvirDukhan

redisgraph/path.py

@@ -1,27 +1,57 @@
+from .node import Node
+from .edge import Edge
 
 class Path(object):
 
-    def __init__(self, nodes, relationships):
+    def __init__(self, nodes, edges):
+        assert(isinstance(nodes, list) and isinstance(edges, list))
         self.nodes = nodes
-        self.relationships = relationships
+        self.edges = edges
+        self.append_type = Node
+
+    @classmethod
+    def new_empty_path(cls):
+        return cls([], [])
+
+    @classmethod
+    def new_path(cls, nodes, edges):
+        return cls(nodes, edges)
 
     def nodes(self):
         return self.nodes
 
-    def relationships(self):
-        return self.relationships
+    def edges(self):
+        return self.edges
 
     def get_node(self, index):
         return self.nodes[index]
 
     def get_relationship(self, index):
-        return self.relationships[index]
+        return self.edges[index]
 
     def first_node(self):
         return self.nodes[0]
 
     def last_node(self):
         return self.nodes[-1]
 
+    def edge_count(self):
+        return len(self.edges)
+    
+    def nodes_count(self):
+        return len(self.nodes)
+
+    def add_node(self, node):
+        assert(isinstance(node, self.append_type))
+        self.nodes.append(node)
+        self.append_type = Edge
+        return self
+
+    def add_edge(self, edge):
+        assert(isinstance(edge, self.append_type))
+        self.edges.append(edge)
+        self.append_type = Node
+        return self
+
     def __eq__(self, other):
-        return self.nodes == other.nodes and self.relationships == other.relationships
+        return self.nodes == other.nodes and self.edges == other.edges

redisgraph/query_result.py

@@ -126,11 +126,10 @@ def parse_edge(self, cell):
         properties = self.parse_entity_properties(cell[4])
         return Edge(src_node_id, relation, dest_node_id, edge_id=edge_id, properties=properties)
 
-
     def parse_path(self, cell):
         nodes = self.parse_scalar(cell[0])
-        relationships = self.parse_scalar(cell[1])
-        return Path(nodes, relationships)
+        edges = self.parse_scalar(cell[1])
+        return Path.new_path(nodes, edges)
 
     def parse_scalar(self, cell):
         scalar_type = int(cell[0])

test.py

@@ -69,21 +69,31 @@ def test_array_functions(self):
     def test_path(self):
         redis_graph = Graph('social', self.r)
 
-        query = """CREATE (a:L1)-[:R1 {value:1}]->(b:L1)-[:R1 {value:2}]->(c:L1)"""
-        redis_graph.query(query)
-        query = "MATCH p=(:L1)-[:R1]->(:L1) RETURN p"
         node0 = Node(node_id=0, label="L1")
-        edge01 = Edge(0, "R1", 1, edge_id=0, properties={'value': 1})
         node1 = Node(node_id=1, label="L1")
-        edge12 = Edge(1, "R1", 2, edge_id=1, properties={'value': 2})
         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.commit()
 
-        path01 = Path([node0, node1], [edge01])
-        path12 = Path([node1, node2], [edge12])
+        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)
         expected_results = [[path01], [path12]]
+
+        query = "MATCH p=(:L1)-[:R1]->(:L1) RETURN p"
         result = redis_graph.query(query)
         self.assertEqual(expected_results, result.result_set)
 
+        # All done, remove graph.
+        redis_graph.delete()
+
 
 if __name__ == '__main__':
 	unittest.main()