Merge branch 'master' into use-f-string-formatting

Author: gkorland

.circleci/config.yml

@@ -20,56 +20,44 @@ jobs:
   build:
     docker:
       - image: circleci/python:3.6.1
-      
+
       - image: redislabs/redisgraph:edge
 
     working_directory: ~/repo
 
     steps:
       - checkout
 
-      # Download and cache dependencies
-      - restore_cache:
-          keys:
-          - v1-dependencies-{{ checksum "requirements.txt" }}
-          # fallback to using the latest cache if no exact match is found
-          - v1-dependencies-
+      - run:
+          name: Install tox
+          command: sudo pip install tox
 
       - run:
-          name: install dependencies
-          command: |
-            python -m venv venv
-            . venv/bin/activate
-            pip install -r requirements.txt
-            pip install codecov
+          name: Test package build
+          command: tox -e sdist
 
-      - save_cache:
-          paths:
-            - ./venv
-          key: v1-dependencies-{{ checksum "requirements.txt" }}
+      - run:
+          name: Run code styles
+          command: tox -e pep8
 
       - run:
-          name: test dist
-          command: python setup.py sdist
+          name: Run unittest with coverage
+          command: tox -e cover
 
       - run:
-          name: run tests
-          command: |
-            . venv/bin/activate
-            coverage run test.py
+          name: Run functional tests
+          command: tox -e func
 
       - early_return_for_forked_pull_requests
 
       - run:
           name: codecove
           command: |
-            . venv/bin/activate
-            codecov
+            . .tox/func/bin/activate
+            codecov --file .tox/cover/report/coverage.xml --name ${CODECOV_NAME}-unittests
+            codecov --file .tox/func/report/coverage.xml --name ${CODECOV_NAME}-functional
+
 
-   #   - store_artifacts:
-   #       path: test-reports
-   #       destination: test-reports
-  
 workflows:
   version: 2
   commit:
@@ -84,4 +72,4 @@ workflows:
               only:
                 - master
     jobs:
-      - build  
+      - build

README.md

@@ -61,7 +61,7 @@ for record in result.result_set:
 	person_age = record[1]
 	visit_purpose = record[2]
 	country_name = record[3]
-	
+
 query = """MATCH p = (:person)-[:visited {purpose:"pleasure"}]->(:country) RETURN p"""
 
 result = redis_graph.query(query)
@@ -88,3 +88,10 @@ pip install redisgraph
 ```
 pip install git+https://github.com/RedisGraph/redisgraph-py.git@master
 ```
+
+### Install for development in env
+
+```
+tox -e env
+source ./tox/env/bin/activate
+```

redisgraph/__init__.py

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

redisgraph/edge.py

@@ -1,16 +1,18 @@
 from redisgraph import Node
 
-from .util import *
+from .util import quote_string
+
 
 class Edge:
     """
     An edge connecting two nodes.
     """
-    def __init__(self, src_node, relation, dest_node, edge_id=None, properties=None):
+    def __init__(self, src_node, relation, dest_node, edge_id=None,
+                 properties=None):
         """
         Create a new edge.
         """
-        if not (src_node and dest_node):
+        if (src_node is None or dest_node is None):
             # NOTE(bors-42): It makes sense to change AssertionError to
             #                ValueError here
             raise AssertionError("Both src_node & dest_node must be provided")

redisgraph/exceptions.py

@@ -1,4 +1,4 @@
+
 class VersionMismatchException(Exception):
     def __init__(self, version):
         self.version = version
-

redisgraph/graph.py

@@ -1,7 +1,9 @@
-from .util import *
 import redis
-from .query_result import QueryResult
-from .exceptions import VersionMismatchException
+
+from redisgraph.util import random_string, quote_string
+from redisgraph.query_result import QueryResult
+from redisgraph.exceptions import VersionMismatchException
+
 
 class Graph:
     """
@@ -151,7 +153,8 @@ def query(self, q, params=None, timeout=None, read_only=False):
         # ask for compact result-set format
         # specify known graph version
         cmd = "GRAPH.RO_QUERY" if read_only else "GRAPH.QUERY"
-        command = [cmd, self.name, query, "--compact", "version", self.version]
+        # command = [cmd, self.name, query, "--compact", "version", self.version]
+        command = [cmd, self.name, query, "--compact"]
 
         # include timeout is specified
         if timeout:
@@ -203,7 +206,7 @@ def merge(self, pattern):
         return self.query(f'MERGE {pattern}')
 
     # Procedures.
-    def call_procedure(self, procedure, read_only=False, *args, **kwagrs):
+    def call_procedure(self, procedure, *args, read_only=False, **kwagrs):
         args = [quote_string(arg) for arg in args]
         query = f'CALL {procedure}({",".join(args)})'
 

redisgraph/node.py

@@ -1,17 +1,18 @@
-from .util import *
+from .util import quote_string
+
 
 class Node:
     """
     A node within the garph.
     """
-    def __init__(self, node_id=None, alias=None, label=None, properties={}):
+    def __init__(self, node_id=None, alias=None, label=None, properties=None):
         """
         Create a new node
         """
         self.id = node_id
         self.alias = alias
         self.label = label
-        self.properties = properties
+        self.properties = properties or {}
 
     def toString(self):
         res = ''

redisgraph/path.py

@@ -1,10 +1,12 @@
 from .node import Node
 from .edge import Edge
 
-class Path:
 
+class Path:
     def __init__(self, nodes, edges):
-        assert(isinstance(nodes, list) and isinstance(edges, list))
+        if not (isinstance(nodes, list) and isinstance(edges, list)):
+            raise TypeError("nodes and edges must be list")
+
         self._nodes = nodes
         self._edges = edges
         self.append_type = Node
@@ -38,13 +40,15 @@ def nodes_count(self):
         return len(self._nodes)
 
     def add_node(self, node):
-        assert(type(node) == self.append_type)
+        if not isinstance(node, self.append_type):
+            raise AssertionError("Add Edge before adding Node")
         self._nodes.append(node)
         self.append_type = Edge
         return self
 
     def add_edge(self, edge):
-        assert(type(edge) == self.append_type)
+        if not isinstance(edge, self.append_type):
+            raise AssertionError("Add Node before adding Edge")
         self._edges.append(edge)
         self.append_type = Node
         return self

redisgraph/query_result.py

@@ -4,6 +4,7 @@
 from .exceptions import VersionMismatchException
 from prettytable import PrettyTable
 from redis import ResponseError
+from collections import OrderedDict
 
 LABELS_ADDED = 'Labels added'
 NODES_CREATED = 'Nodes created'
@@ -17,15 +18,17 @@
 INTERNAL_EXECUTION_TIME = 'internal execution time'
 
 STATS = [LABELS_ADDED, NODES_CREATED, PROPERTIES_SET, RELATIONSHIPS_CREATED,
-        NODES_DELETED, RELATIONSHIPS_DELETED, INDICES_CREATED, INDICES_DELETED,
-        CACHED_EXECUTION, INTERNAL_EXECUTION_TIME]
+         NODES_DELETED, RELATIONSHIPS_DELETED, INDICES_CREATED, INDICES_DELETED,
+         CACHED_EXECUTION, INTERNAL_EXECUTION_TIME]
+
 
 class ResultSetColumnTypes:
     COLUMN_UNKNOWN = 0
     COLUMN_SCALAR = 1
     COLUMN_NODE = 2       # Unused as of RedisGraph v2.1.0, retained for backwards compatibility.
     COLUMN_RELATION = 3   # Unused as of RedisGraph v2.1.0, retained for backwards compatibility.
 
+
 class ResultSetScalarTypes:
     VALUE_UNKNOWN = 0
     VALUE_NULL = 1
@@ -37,6 +40,9 @@ class ResultSetScalarTypes:
     VALUE_EDGE = 7
     VALUE_NODE = 8
     VALUE_PATH = 9
+    VALUE_MAP = 10
+    VALUE_POINT = 11
+
 
 class QueryResult:
 
@@ -122,6 +128,14 @@ def parse_entity_properties(self, props):
 
         return properties
 
+    def parse_string(self, cell):
+        if isinstance(cell, bytes):
+            return cell.decode()
+        elif not isinstance(cell, str):
+            return str(cell)
+        else:
+            return cell
+
     def parse_node(self, cell):
         # Node ID (integer),
         # [label string offset (integer)],
@@ -153,6 +167,27 @@ def parse_path(self, cell):
         edges = self.parse_scalar(cell[1])
         return Path(nodes, edges)
 
+    def parse_map(self, cell):
+        m = OrderedDict()
+        n_entries = len(cell)
+
+        # A map is an array of key value pairs.
+        # 1. key (string)
+        # 2. array: (value type, value)
+        for i in range(0, n_entries, 2):
+            key = self.parse_string(cell[i])
+            m[key] = self.parse_scalar(cell[i+1])
+
+        return m
+
+    def parse_point(self, cell):
+        p = {}
+        # A point is received an array of the form: [latitude, longitude]
+        # It is returned as a map of the form: {"latitude": latitude, "longitude": longitude}
+        p["latitude"] = float(cell[0])
+        p["longitude"] = float(cell[1])
+        return p
+
     def parse_scalar(self, cell):
         scalar_type = int(cell[0])
         value = cell[1]
@@ -162,12 +197,7 @@ def parse_scalar(self, cell):
             scalar = None
 
         elif scalar_type == ResultSetScalarTypes.VALUE_STRING:
-            if isinstance(value, bytes):
-                scalar = value.decode()
-            elif not isinstance(value, str):
-                scalar = str(value)
-            else:
-                scalar = value
+            scalar = self.parse_string(value)
 
         elif scalar_type == ResultSetScalarTypes.VALUE_INTEGER:
             scalar = int(value)
@@ -199,6 +229,12 @@ def parse_scalar(self, cell):
         elif scalar_type == ResultSetScalarTypes.VALUE_PATH:
             scalar = self.parse_path(value)
 
+        elif scalar_type == ResultSetScalarTypes.VALUE_MAP:
+            scalar = self.parse_map(value)
+
+        elif scalar_type == ResultSetScalarTypes.VALUE_POINT:
+            scalar = self.parse_point(value)
+
         elif scalar_type == ResultSetScalarTypes.VALUE_UNKNOWN:
             print("Unknown scalar type\n")
 
@@ -288,4 +324,3 @@ def cached_execution(self):
     @property
     def run_time_ms(self):
         return self._get_stat(INTERNAL_EXECUTION_TIME)
-

redisgraph/util.py

@@ -25,6 +25,8 @@ def quote_string(v):
     if len(v) == 0:
         return '""'
 
+    v = v.replace('"', '\\"')
+
     if v[0] != '"':
         v = '"' + v
 

setup.py

@@ -11,7 +11,7 @@ def read_all(f):
 
 setup(
     name='redisgraph',
-    version='2.2.3',
+    version='2.3.0',
     description='RedisGraph Python Client',
     long_description=read_all("README.md"),
     long_description_content_type='text/markdown',

test-requirements.txt

@@ -0,0 +1,10 @@
+flake8
+
+pytest
+pytest-cov
+pytest-html
+
+testtools>=1.4.0
+mock
+
+codecov