Reset some bigger changes by relocating data method

Author: technige

neo4j/v1/api.py

@@ -26,7 +26,7 @@
 from warnings import warn
 
 from neo4j.exceptions import ProtocolError, ServiceUnavailable
-from neo4j.compat import urlparse, integer, string
+from neo4j.compat import urlparse
 from neo4j.exceptions import CypherError, TransientError
 from neo4j.config import default_config
 
@@ -81,11 +81,6 @@ class GraphDatabase(object):
 
     value_systems = {}
 
-    @classmethod
-    def register_value_system(cls, value_system_class):
-        if value_system_class.__name__ not in cls.value_systems:
-            cls.value_systems[value_system_class.__name__] = value_system_class()
-
     @classmethod
     def driver(cls, uri, **config):
         """ Acquire a :class:`.Driver` instance for the given URI and
@@ -638,167 +633,6 @@ def closed(self):
         return self._closed
 
 
-class Record(object):
-    """ Record is an ordered collection of fields.
-
-    A Record object is used for storing result values along with field names.
-    Fields can be accessed by numeric or named index (``record[0]`` or
-    ``record["field"]``).
-    """
-
-    def __init__(self, keys, values):
-        self._keys = tuple(keys)
-        self._values = tuple(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 __hash__(self):
-        return hash(self._keys) ^ hash(self._values)
-
-    def __eq__(self, other):
-        try:
-            return (self._keys == tuple(other.keys()) and
-                    self._values == tuple(other.values()))
-        except AttributeError:
-            return False
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __len__(self):
-        return len(self._keys)
-
-    def __getitem__(self, item):
-        if isinstance(item, string):
-            return self._values[self.index(item)]
-        elif isinstance(item, integer):
-            return self._values[item]
-        else:
-            raise TypeError(item)
-
-    def __iter__(self):
-        return iter(self._keys)
-
-    def __contains__(self, key):
-        try:
-            self.index(key)
-        except (IndexError, KeyError):
-            return False
-        else:
-            return True
-
-    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 StatementResult(object):
     """ A handler for the result of Cypher statement execution. Instances
     of this class are typically constructed and returned by
@@ -813,7 +647,7 @@ class StatementResult(object):
 
     value_system = None
 
-    zipper = Record
+    zipper = zip
 
     _session = None
 
@@ -945,21 +779,6 @@ def peek(self):
                 return zipper(keys, hydrate(values))
         return None
 
-    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()]
-
 
 def fix_statement(statement):
     if isinstance(statement, bytes):

neo4j/v1/result.py

@@ -22,8 +22,8 @@
 from collections import namedtuple
 
 from neo4j.exceptions import CypherError
-from neo4j.v1.api import GraphDatabase, StatementResult, Record
-from neo4j.v1.types import PackStreamValueSystem
+from neo4j.v1.api import GraphDatabase, StatementResult
+from neo4j.v1.types import Record
 
 
 STATEMENT_TYPE_READ_ONLY = "r"
@@ -32,14 +32,11 @@
 STATEMENT_TYPE_SCHEMA_WRITE = "s"
 
 
-GraphDatabase.register_value_system(PackStreamValueSystem)
-
-
 class BoltStatementResult(StatementResult):
     """ A handler for the result of Cypher statement execution.
     """
 
-    value_system = GraphDatabase.value_systems[PackStreamValueSystem.__name__]
+    value_system = GraphDatabase.value_systems["packstream"]
 
     zipper = Record
 
@@ -78,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.