Drop list stream and map stream from packstream implementation

neo4j/packstream.py

@@ -38,9 +38,6 @@
 INT64_MAX = 2 ** 63
 
 
-EndOfStream = object()
-
-
 class Structure:
 
     def __init__(self, tag, *fields):
@@ -196,9 +193,6 @@ def pack_list_header(self, size):
         else:
             raise OverflowError("List header size out of range")
 
-    def pack_list_stream_header(self):
-        self._write(b"\xD7")
-
     def pack_map_header(self, size):
         write = self._write
         if size <= 0x0F:
@@ -215,9 +209,6 @@ def pack_map_header(self, size):
         else:
             raise OverflowError("Map header size out of range")
 
-    def pack_map_stream_header(self):
-        self._write(b"\xDB")
-
     def pack_struct(self, signature, fields):
         if len(signature) != 1 or not isinstance(signature, bytes):
             raise ValueError("Structure signature must be a single byte value")
@@ -231,9 +222,6 @@ def pack_struct(self, signature, fields):
         for field in fields:
             self._pack(field)
 
-    def pack_end_of_stream(self):
-        self._write(b"\xDF")
-
 
 class Unpacker:
 
@@ -316,11 +304,11 @@ def _unpack(self):
                 return decode(self.read(size), "utf-8")
 
             # List
-            elif 0x90 <= marker <= 0x9F or 0xD4 <= marker <= 0xD7:
+            elif 0x90 <= marker <= 0x9F or 0xD4 <= marker <= 0xD6:
                 return list(self._unpack_list_items(marker))
 
             # Map
-            elif 0xA0 <= marker <= 0xAF or 0xD8 <= marker <= 0xDB:
+            elif 0xA0 <= marker <= 0xAF or 0xD8 <= marker <= 0xDA:
                 return self._unpack_map(marker)
 
             # Structure
@@ -331,9 +319,6 @@ def _unpack(self):
                     value[i] = self._unpack()
                 return value
 
-            elif marker == 0xDF:  # END_OF_STREAM:
-                return EndOfStream
-
             else:
                 raise ValueError("Unknown PackStream marker %02X" % marker)
 
@@ -360,12 +345,6 @@ def _unpack_list_items(self, marker):
             size, = struct_unpack(">I", self.read(4))
             for _ in range(size):
                 yield self._unpack()
-        elif marker == 0xD7:  # LIST_STREAM:
-            item = None
-            while item is not EndOfStream:
-                item = self._unpack()
-                if item is not EndOfStream:
-                    yield item
         else:
             return
 
@@ -403,14 +382,6 @@ def _unpack_map(self, marker):
                 key = self._unpack()
                 value[key] = self._unpack()
             return value
-        elif marker == 0xDB:  # MAP_STREAM:
-            value = {}
-            key = None
-            while key is not EndOfStream:
-                key = self._unpack()
-                if key is not EndOfStream:
-                    value[key] = self._unpack()
-            return value
         else:
             return None
 

tests/unit/common/data/test_packing.py

@@ -221,29 +221,6 @@ def test_list_32(self):
     def test_nested_lists(self):
         self.assert_packable([[[]]], b"\x91\x91\x90")
 
-    def test_list_stream(self):
-        packed_value = b"\xD7\x01\x02\x03\xDF"
-        unpacked_value = [1, 2, 3]
-        stream_out = BytesIO()
-        packer = Packer(stream_out)
-        packer.pack_list_stream_header()
-        packer.pack(1)
-        packer.pack(2)
-        packer.pack(3)
-        packer.pack_end_of_stream()
-        packed = stream_out.getvalue()
-        try:
-            assert packed == packed_value
-        except AssertionError:
-            raise AssertionError("Packed value is %r instead of expected %r" %
-                                 (packed, packed_value))
-        unpacked = Unpacker(UnpackableBuffer(packed)).unpack()
-        try:
-            assert unpacked == unpacked_value
-        except AssertionError:
-            raise AssertionError("Unpacked value %r is not equal to expected %r" %
-                                 (unpacked, unpacked_value))
-
     def test_list_size_overflow(self):
         stream_out = BytesIO()
         packer = Packer(stream_out)
@@ -277,30 +254,6 @@ def test_map_32(self):
         b = b"".join(self.packb(u"A%s" % i, 1) for i in range(80000))
         self.assert_packable(d, b"\xDA\x00\x01\x38\x80" + b)
 
-    def test_map_stream(self):
-        packed_value = b"\xDB\x81A\x01\x81B\x02\xDF"
-        unpacked_value = {u"A": 1, u"B": 2}
-        stream_out = BytesIO()
-        packer = Packer(stream_out)
-        packer.pack_map_stream_header()
-        packer.pack(u"A")
-        packer.pack(1)
-        packer.pack(u"B")
-        packer.pack(2)
-        packer.pack_end_of_stream()
-        packed = stream_out.getvalue()
-        try:
-            assert packed == packed_value
-        except AssertionError:
-            raise AssertionError("Packed value is %r instead of expected %r" %
-                                 (packed, packed_value))
-        unpacked = Unpacker(UnpackableBuffer(packed)).unpack()
-        try:
-            assert unpacked == unpacked_value
-        except AssertionError:
-            raise AssertionError("Unpacked value %r is not equal to expected %r" %
-                                 (unpacked, unpacked_value))
-
     def test_map_size_overflow(self):
         stream_out = BytesIO()
         packer = Packer(stream_out)