add support for path type

redisgraph/__init__.py

@@ -1,3 +1,4 @@
 from .node import Node
 from .edge import Edge
 from .graph import Graph
+from .path import Path

redisgraph/path.py

@@ -0,0 +1,57 @@
+from .node import Node
+from .edge import Edge
+
+class Path(object):
+
+    def __init__(self, nodes, edges):
+        assert(isinstance(nodes, list) and isinstance(edges, list))
+        self.nodes = nodes
+        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 edges(self):
+        return self.edges
+
+    def get_node(self, index):
+        return self.nodes[index]
+
+    def get_relationship(self, 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.edges == other.edges

redisgraph/query_result.py

@@ -1,5 +1,6 @@
 from .node import Node
 from .edge import Edge
+from .path import Path
 from prettytable import PrettyTable
 from redis import ResponseError
 
@@ -21,6 +22,7 @@ class ResultSetScalarTypes(object):
     VALUE_ARRAY = 6
     VALUE_EDGE = 7
     VALUE_NODE = 8
+    VALUE_PATH = 9
 
 class QueryResult(object):
     LABELS_ADDED = 'Labels added'
@@ -124,6 +126,11 @@ 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])
+        edges = self.parse_scalar(cell[1])
+        return Path.new_path(nodes, edges)
+
     def parse_scalar(self, cell):
         scalar_type = int(cell[0])
         value = cell[1]
@@ -162,6 +169,9 @@ def parse_scalar(self, cell):
         elif scalar_type == ResultSetScalarTypes.VALUE_EDGE:
             scalar = self.parse_edge(value)
 
+        elif scalar_type == ResultSetScalarTypes.VALUE_PATH:
+            scalar = self.parse_path(value)
+
         elif scalar_type == ResultSetScalarTypes.VALUE_UNKNOWN:
             print("Unknown scalar type\n")
 

test.py

@@ -65,5 +65,35 @@ def test_array_functions(self):
         # All done, remove graph.
         redis_graph.delete()
 
+
+    def test_path(self):
+        redis_graph = Graph('social', self.r)
+
+        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.commit()
+
+        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()