Merge branch '1.6' into 1.5

Author: technige

neo4j/meta.py

@@ -19,4 +19,4 @@
 # limitations under the License.
 
 
-version = "1.5.0"
+version = "1.6.0"

neo4j/v1/api.py

@@ -779,11 +779,6 @@ def peek(self):
                 return zipper(keys, hydrate(values))
         return None
 
-    def data(self):
-        """ Return the remainder of the result as a list of dictionaries.
-        """
-        return [dict(record) for record in self]
-
 
 def fix_statement(statement):
     if isinstance(statement, bytes):

neo4j/v1/result.py

@@ -75,6 +75,21 @@ def on_failure(metadata):
         pull_all_response.on_success = on_footer
         pull_all_response.on_failure = on_failure
 
+    def value(self, item=0, default=None):
+        """ Return the remainder of the result as a list of values.
+        """
+        return [record.value(item, default) for record in self.records()]
+
+    def values(self, *items):
+        """ Return the remainder of the result as a list of tuples.
+        """
+        return [record.values(*items) for record in self.records()]
+
+    def data(self, *items):
+        """ Return the remainder of the result as a list of dictionaries.
+        """
+        return [record.data(*items) for record in self.records()]
+
 
 class BoltStatementResultSummary(object):
     """ A summary of execution returned with a :class:`.StatementResult` object.

neo4j/v1/types.py

@@ -43,40 +43,28 @@ def __init__(self, keys, values):
         self._keys = tuple(keys)
         self._values = tuple(values)
 
-    def keys(self):
-        """ Return the keys (key names) of the record
-        """
-        return self._keys
-
-    def values(self):
-        """ Return the values of the record
-        """
-        return self._values
+    def __repr__(self):
+        values = self._values
+        s = []
+        for i, field in enumerate(self._keys):
+            s.append("%s=%r" % (field, values[i]))
+        return "<%s %s>" % (self.__class__.__name__, " ".join(s))
 
-    def items(self):
-        """ Return the fields of the record as a list of key and value tuples
-        """
-        return zip(self._keys, self._values)
+    def __hash__(self):
+        return hash(self._keys) ^ hash(self._values)
 
-    def index(self, key):
-        """ Return the index of the given key
-        """
+    def __eq__(self, other):
         try:
-            return self._keys.index(key)
-        except ValueError:
-            raise KeyError(key)
-
-    def __record__(self):
-        return self
-
-    def __contains__(self, key):
-        return self._keys.__contains__(key)
+            return (self._keys == tuple(other.keys()) and
+                    self._values == tuple(other.values()))
+        except AttributeError:
+            return False
 
-    def __iter__(self):
-        return iter(self._keys)
+    def __ne__(self, other):
+        return not self.__eq__(other)
 
-    def copy(self):
-        return Record(self._keys, self._values)
+    def __len__(self):
+        return len(self._keys)
 
     def __getitem__(self, item):
         if isinstance(item, string):
@@ -86,27 +74,122 @@ def __getitem__(self, item):
         else:
             raise TypeError(item)
 
-    def __len__(self):
-        return len(self._keys)
-
-    def __repr__(self):
-        values = self._values
-        s = []
-        for i, field in enumerate(self._keys):
-            s.append("%s=%r" % (field, values[i]))
-        return "<Record %s>" % " ".join(s)
-
-    def __hash__(self):
-        return hash(self._keys) ^ hash(self._values)
+    def __iter__(self):
+        return iter(self._keys)
 
-    def __eq__(self, other):
+    def __contains__(self, key):
         try:
-            return self._keys == tuple(other.keys()) and self._values == tuple(other.values())
-        except AttributeError:
+            self.index(key)
+        except (IndexError, KeyError):
             return False
+        else:
+            return True
 
-    def __ne__(self, other):
-        return not self.__eq__(other)
+    def index(self, item):
+        """ Return the index of the given item.
+        """
+        if isinstance(item, integer):
+            if 0 <= item < len(self._keys):
+                return item
+            raise IndexError(item)
+        if isinstance(item, string):
+            try:
+                return self._keys.index(item)
+            except ValueError:
+                raise KeyError(item)
+        raise TypeError(item)
+
+    def value(self, item=0, default=None):
+        """ Obtain a single value from the record by index or key. If no
+        index or key is specified, the first value is returned. If the
+        specified item does not exist, the default value is returned.
+
+        :param item:
+        :param default:
+        :return:
+        """
+        try:
+            index = self.index(item)
+        except (IndexError, KeyError):
+            return default
+        else:
+            return self._values[index]
+
+    def keys(self):
+        """ Return the keys of the record.
+
+        :return: tuple of key names
+        """
+        return self._keys
+
+    def values(self, *items):
+        """ Return the values of the record, optionally filtering to
+        include only certain values by index or key.
+
+        :param items: indexes or keys of the items to include; if none
+                          are provided, all values will be included
+        :return: tuple of values
+        """
+        if items:
+            d = []
+            values = self._values
+            for item in items:
+                try:
+                    i = self.index(item)
+                except KeyError:
+                    d.append(None)
+                else:
+                    d.append(values[i])
+            return tuple(d)
+        return self._values
+
+    def items(self, *items):
+        """ Return the fields of the record as a list of key and value tuples
+
+        :return:
+        """
+        if items:
+            d = []
+            keys = self._keys
+            values = self._values
+            for item in items:
+                try:
+                    i = self.index(item)
+                except KeyError:
+                    d.append((item, None))
+                else:
+                    d.append((keys[i], values[i]))
+            return d
+        return list(zip(self._keys, self._values))
+
+    def data(self, *items):
+        """ Return the keys and values of this record as a dictionary,
+        optionally including only certain values by index or key. Keys
+        provided in the items that are not in the record will be
+        inserted with a value of :py:const:`None`; indexes provided
+        that are out of bounds will trigger an :py:`IndexError`.
+
+        :param items: indexes or keys of the items to include; if none
+                          are provided, all values will be included
+        :return: dictionary of values, keyed by field name
+        :raises: :py:`IndexError` if an out-of-bounds index is specified
+        """
+        if items:
+            d = {}
+            keys = self._keys
+            values = self._values
+            for item in items:
+                try:
+                    i = self.index(item)
+                except KeyError:
+                    d[item] = None
+                else:
+                    d[keys[i]] = values[i]
+            return d
+        return dict(self)
+
+    def copy(self):
+        return self.__class__(self._keys, self._values)
 
 
 class Entity(object):