gremlinpython 4.0.0b2__py3-none-any.whl → 4.0.0.dev1__py3-none-any.whl

gremlin_python/structure/io/graphbinaryV4.py

@@ -27,10 +27,11 @@ from datetime import datetime, timedelta, timezone
 from struct import pack, unpack
 
 from aenum import Enum
-from gremlin_python.process.traversal import Direction, T, Merge, GType
+from gremlin_python.process.traversal import Direction, T, Merge
 from gremlin_python.statics import FloatType, BigDecimal, ShortType, IntType, LongType, BigIntType, \
     DictType, SetType, SingleByte, SingleChar
-from gremlin_python.structure.graph import Graph, Edge, Property, Vertex, VertexProperty, Path
+from gremlin_python.structure.graph import Graph, Edge, Property, Vertex, VertexProperty, Path, CompositePDT, \
+    PrimitivePDT, Tree, _pdt_decorated_types
 from gremlin_python.structure.io.util import HashableDict, SymbolUtil, Marker
 
 log = logging.getLogger(__name__)
@@ -69,16 +70,19 @@ class DataType(Enum):
     binary = 0x25
     short = 0x26
     boolean = 0x27
-    tree = 0x2b                   # not supported - no tree object in Python yet
-    gtype = 0x30
+    tree = 0x2b
     char = 0x80
     duration = 0x81
+    composite_pdt = 0xf0
+    primitive_pdt = 0xf1
     marker = 0xfd
-    custom = 0x00                 # todo
 
 
 NULL_BYTES = [DataType.null.value, 0x01]
 
+# null type code as a plain int, so the per-read null check skips the aenum lookup
+_NULL = DataType.null.value
+
 
 def _make_packer(format_string):
     packer = struct.Struct(format_string)
@@ -144,27 +148,65 @@ class GraphBinaryWriter(object):
 
 
 class GraphBinaryReader(object):
-    def __init__(self, deserializer_map=None):
+    def __init__(self, deserializer_map=None, pdt_registry=None):
         self.deserializers = _deserializers.copy()
         if deserializer_map:
             self.deserializers.update(deserializer_map)
+        self.pdt_registry = pdt_registry
+        # Mirror of self.deserializers keyed by int type code instead of DataType.
+        # Avoids the per-read DataType(bt) call, whose aenum construction negatively affects performance on large results.
+        self._deserializer_by_type_code = {dt.value: des.objectify for dt, des in self.deserializers.items()}
 
     def read_object(self, b):
+        if b is None:
+            return None
         if isinstance(b, bytearray):
             return self.to_object(io.BytesIO(b))
-        elif isinstance(b, io.BufferedIOBase):
-            return self.to_object(b)
+        return self.to_object(b)
 
     def to_object(self, buff, data_type=None, nullable=True):
         if data_type is None:
             bt = uint8_unpack(buff.read(1))
-            if bt == DataType.null.value:
+            if bt == _NULL:
                 if nullable:
                     buff.read(1)
                 return None
-            return self.deserializers[DataType(bt)].objectify(buff, self, nullable)
+            try:
+                objectify = self._deserializer_by_type_code[bt]
+            except KeyError:
+                raise ValueError("%r is not a valid DataType" % bt) from None
+            result = objectify(buff, self, nullable)
         else:
-            return self.deserializers[data_type].objectify(buff, self, nullable)
+            result = self.deserializers[data_type].objectify(buff, self, nullable)
+        if self.pdt_registry is not None and isinstance(result, PrimitivePDT):
+            hydrated = self.pdt_registry.hydrate_primitive(result)
+            if not isinstance(hydrated, PrimitivePDT):
+                return hydrated
+            result = hydrated
+        if self.pdt_registry is not None and isinstance(result, CompositePDT):
+            hydrated = self.pdt_registry.hydrate(result)
+            if not isinstance(hydrated, CompositePDT):
+                return hydrated
+            result = hydrated
+        if isinstance(result, CompositePDT) and result.name in _pdt_decorated_types:
+            return self._hydrate_decorated(result)
+        return result
+
+    def _hydrate_decorated(self, pdt):
+        """Hydrate a CompositePDT using a @provider_defined decorated class."""
+        cls = _pdt_decorated_types[pdt.name]
+        fields = {}
+        for k, v in pdt.fields.items():
+            if isinstance(v, CompositePDT) and v.name in _pdt_decorated_types:
+                fields[k] = self._hydrate_decorated(v)
+            elif self.pdt_registry is not None and isinstance(v, CompositePDT):
+                fields[k] = self.pdt_registry.hydrate(v)
+            else:
+                fields[k] = v
+        obj = cls.__new__(cls)
+        for k, v in fields.items():
+            setattr(obj, k, v)
+        return obj
 
 
 class _GraphBinaryTypeIO(object, metaclass=GraphBinaryTypeType):
@@ -567,12 +609,21 @@ class EdgeIO(_GraphBinaryTypeIO):
         cls.prefix_bytes(cls.graphbinary_type, as_value, nullable, to_extend)
 
         writer.to_dict(obj.id, to_extend)
-        # serializing label as list here for now according to GraphBinaryV4
-        ListIO.dictify([obj.label], writer, to_extend, True, False)
+        # serializing labels as list according to GraphBinaryV4
+        if hasattr(obj, '_labels'):
+            ListIO.dictify(list(obj._labels), writer, to_extend, True, False)
+        else:
+            ListIO.dictify([obj.label], writer, to_extend, True, False)
         writer.to_dict(obj.inV.id, to_extend)
-        ListIO.dictify([obj.inV.label], writer, to_extend, True, False)
+        if hasattr(obj.inV, '_labels'):
+            ListIO.dictify(list(obj.inV._labels), writer, to_extend, True, False)
+        else:
+            ListIO.dictify([obj.inV.label], writer, to_extend, True, False)
         writer.to_dict(obj.outV.id, to_extend)
-        ListIO.dictify([obj.outV.label], writer, to_extend, True, False)
+        if hasattr(obj.outV, '_labels'):
+            ListIO.dictify(list(obj.outV._labels), writer, to_extend, True, False)
+        else:
+            ListIO.dictify([obj.outV.label], writer, to_extend, True, False)
         to_extend.extend(NULL_BYTES)
         to_extend.extend(NULL_BYTES)
 
@@ -585,15 +636,19 @@ class EdgeIO(_GraphBinaryTypeIO):
     @classmethod
     def _read_edge(cls, b, r):
         edgeid = r.read_object(b)
-        # reading single string value for now according to GraphBinaryV4
-        edgelbl = r.to_object(b, DataType.list, False)[0]
-        inv = Vertex(r.read_object(b), r.to_object(b, DataType.list, False)[0])
-        outv = Vertex(r.read_object(b), r.to_object(b, DataType.list, False)[0])
+        # reading label list according to GraphBinaryV4
+        edge_labels = r.to_object(b, DataType.list, False)
+        inv_id = r.read_object(b)
+        inv_labels = r.to_object(b, DataType.list, False)
+        inv = Vertex(inv_id, labels=inv_labels)
+        outv_id = r.read_object(b)
+        outv_labels = r.to_object(b, DataType.list, False)
+        outv = Vertex(outv_id, labels=outv_labels)
         b.read(2)
         props = r.read_object(b)
         # null properties are returned as empty lists
         properties = [] if props is None else props
-        edge = Edge(edgeid, outv, edgelbl, inv, properties)
+        edge = Edge(edgeid, outv, edge_labels[0] if edge_labels else "edge", inv, properties, labels=edge_labels)
         return edge
 
 
@@ -614,6 +669,42 @@ class PathIO(_GraphBinaryTypeIO):
         return cls.is_null(buff, reader, lambda b, r: Path(r.read_object(b), r.read_object(b)), nullable)
 
 
+class TreeIO(_GraphBinaryTypeIO):
+
+    python_type = Tree
+    graphbinary_type = DataType.tree
+
+    @classmethod
+    def dictify(cls, obj, writer, to_extend, as_value=False, nullable=True):
+        # when as_value (a nested/bare child tree) prefix_bytes writes nothing:
+        # no type-id and no null flag. As a root value it writes {type-id}{null flag}.
+        cls.prefix_bytes(cls.graphbinary_type, as_value, nullable, to_extend)
+        root_nodes = obj.root_nodes()
+        to_extend.extend(int32_pack(len(root_nodes)))
+        for key in root_nodes:
+            child = obj.child_at(key)
+            # key is written fully-qualified (its own type-id + null flag + value)
+            writer.to_dict(key, to_extend)
+            # child is written as a BARE tree value: no type-id, no null flag
+            cls.dictify(child, writer, to_extend, as_value=True, nullable=False)
+        return to_extend
+
+    @classmethod
+    def objectify(cls, buff, reader, nullable=True):
+        return cls.is_null(buff, reader, cls._read_tree, nullable)
+
+    @classmethod
+    def _read_tree(cls, b, r):
+        size = cls.read_int(b)
+        tree = Tree()
+        while size > 0:
+            key = r.read_object(b)
+            child = cls.objectify(b, r, False)
+            tree.get_or_create_child(key).add_tree(child)
+            size = size - 1
+        return tree
+
+
 class PropertyIO(_GraphBinaryTypeIO):
 
     python_type = Property
@@ -653,7 +744,10 @@ class TinkerGraphIO(_GraphBinaryTypeIO):
         IntIO.dictify(len(vertices), writer, to_extend, True, False)
         for v in vertices:
             writer.to_dict(v.id, to_extend)
-            ListIO.dictify([v.label], writer, to_extend, True, False)
+            if hasattr(v, '_labels'):
+                ListIO.dictify(list(v._labels), writer, to_extend, True, False)
+            else:
+                ListIO.dictify([v.label], writer, to_extend, True, False)
             v_props = v.properties
             IntIO.dictify(len(v_props), writer, to_extend, True, False)
             for vp in v_props:
@@ -666,7 +760,10 @@ class TinkerGraphIO(_GraphBinaryTypeIO):
         IntIO.dictify(len(edges), writer, to_extend, True, False)
         for e in edges:
             writer.to_dict(e.id, to_extend)
-            ListIO.dictify([e.label], writer, to_extend, True, False)
+            if hasattr(e, '_labels'):
+                ListIO.dictify(list(e._labels), writer, to_extend, True, False)
+            else:
+                ListIO.dictify([e.label], writer, to_extend, True, False)
             writer.to_dict(e.inV.id, to_extend)
             writer.to_dict(None, to_extend)
             writer.to_dict(e.outV.id, to_extend)
@@ -686,8 +783,8 @@ class TinkerGraphIO(_GraphBinaryTypeIO):
         vertex_count = r.to_object(b, DataType.int, False)
         for _ in range(vertex_count):
             v_id = r.read_object(b)
-            v_label = r.to_object(b, DataType.list, False)[0]
-            vertex = Vertex(v_id, v_label)
+            v_labels = r.to_object(b, DataType.list, False)
+            vertex = Vertex(v_id, v_labels[0] if v_labels else "vertex", labels=v_labels)
             graph.vertices[v_id] = vertex
 
             vp_count = r.to_object(b, DataType.int, False)
@@ -706,14 +803,15 @@ class TinkerGraphIO(_GraphBinaryTypeIO):
         edge_count = r.to_object(b, DataType.int, False)
         for _ in range(edge_count):
             e_id = r.read_object(b)
-            e_label = r.to_object(b, DataType.list, False)[0]
+            e_labels = r.to_object(b, DataType.list, False)
             in_v_id = r.read_object(b)
             r.read_object(b)  # discard in-v label
             out_v_id = r.read_object(b)
             r.read_object(b)  # discard out-v label
             r.read_object(b)  # discard parent
 
-            edge = Edge(e_id, graph.vertices[out_v_id], e_label, graph.vertices[in_v_id])
+            edge = Edge(e_id, graph.vertices[out_v_id], e_labels[0] if e_labels else "edge",
+                        graph.vertices[in_v_id], labels=e_labels)
             graph.edges[e_id] = edge
 
             edge_props = r.to_object(b, DataType.list, False)
@@ -732,8 +830,11 @@ class VertexIO(_GraphBinaryTypeIO):
     def dictify(cls, obj, writer, to_extend, as_value=False, nullable=True):
         cls.prefix_bytes(cls.graphbinary_type, as_value, nullable, to_extend)
         writer.to_dict(obj.id, to_extend)
-        # serializing label as list here for now according to GraphBinaryV4
-        ListIO.dictify([obj.label], writer, to_extend, True, False)
+        # serializing labels as list according to GraphBinaryV4
+        if hasattr(obj, '_labels'):
+            ListIO.dictify(list(obj._labels), writer, to_extend, True, False)
+        else:
+            ListIO.dictify([obj.label], writer, to_extend, True, False)
         to_extend.extend(NULL_BYTES)
         return to_extend
 
@@ -744,12 +845,12 @@ class VertexIO(_GraphBinaryTypeIO):
     @classmethod
     def _read_vertex(cls, b, r):
         vertex_id = r.read_object(b)
-        # reading single string value for now according to GraphBinaryV4
-        vertex_label = r.to_object(b, DataType.list, False)[0]
+        # reading label list according to GraphBinaryV4
+        vertex_labels = r.to_object(b, DataType.list, False)
         props = r.read_object(b)
         # null properties are returned as empty lists
         properties = [] if props is None else props
-        vertex = Vertex(vertex_id, vertex_label, properties)
+        vertex = Vertex(vertex_id, properties=properties, labels=vertex_labels)
         return vertex
 
 
@@ -824,11 +925,6 @@ class MergeIO(_EnumIO):
     python_type = Merge
 
 
-class GTYPEIO(_EnumIO):
-    graphbinary_type = DataType.gtype
-    python_type = GType
-
-
 class ByteIO(_GraphBinaryTypeIO):
     python_type = SingleByte
     graphbinary_type = DataType.byte
@@ -920,4 +1016,48 @@ class MarkerIO(_GraphBinaryTypeIO):
     def objectify(cls, buff, reader, nullable=True):
         return cls.is_null(buff, reader,
                            lambda b, r: Marker.of(int8_unpack(b.read(1))),
-                           nullable)
+                           nullable)
+
+
+class CompositePDTIO(_GraphBinaryTypeIO):
+    python_type = CompositePDT
+    graphbinary_type = DataType.composite_pdt
+
+    @classmethod
+    def dictify(cls, obj, writer, to_extend, as_value=False, nullable=True):
+        cls.prefix_bytes(cls.graphbinary_type, as_value, nullable, to_extend)
+        StringIO.dictify(obj.name, writer, to_extend)
+        MapIO.dictify(obj.fields, writer, to_extend)
+        return to_extend
+
+    @classmethod
+    def objectify(cls, buff, reader, nullable=True):
+        return cls.is_null(buff, reader, cls._read_pdt, nullable)
+
+    @classmethod
+    def _read_pdt(cls, b, r):
+        name = r.read_object(b)
+        fields = r.read_object(b)
+        return CompositePDT(name, fields)
+
+
+class PrimitivePDTIO(_GraphBinaryTypeIO):
+    python_type = PrimitivePDT
+    graphbinary_type = DataType.primitive_pdt
+
+    @classmethod
+    def dictify(cls, obj, writer, to_extend, as_value=False, nullable=True):
+        cls.prefix_bytes(cls.graphbinary_type, as_value, nullable, to_extend)
+        StringIO.dictify(obj.name, writer, to_extend)
+        StringIO.dictify(obj.value, writer, to_extend)
+        return to_extend
+
+    @classmethod
+    def objectify(cls, buff, reader, nullable=True):
+        return cls.is_null(buff, reader, cls._read_primitive_pdt, nullable)
+
+    @classmethod
+    def _read_primitive_pdt(cls, b, r):
+        name = r.read_object(b)
+        value = r.read_object(b)
+        return PrimitivePDT(name, value)

{gremlinpython-4.0.0b2.dist-info → gremlinpython-4.0.0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gremlinpython
-Version: 4.0.0b2
+Version: 4.0.0.dev1
 Summary: Gremlin-Python for Apache TinkerPop
 Maintainer-email: Apache TinkerPop <dev@tinkerpop.apache.org>
 License: Apache 2
@@ -9,19 +9,21 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: nest_asyncio
-Requires-Dist: aiohttp<4.0.0,>=3.8.0
+Requires-Dist: aiohttp<4.0.0,>=3.11.0
 Requires-Dist: aenum<4.0.0,>=1.4.5
 Requires-Dist: isodate<1.0.0,>=0.6.0
 Requires-Dist: boto3
 Requires-Dist: botocore
 Requires-Dist: async-timeout<5.0,>=4.0.3; python_version < "3.11"
-Provides-Extra: kerberos
-Requires-Dist: kerberos<2.0.0,>=1.3.0; sys_platform != "win32" and extra == "kerberos"
 Provides-Extra: ujson
 Requires-Dist: ujson>=2.0.0; extra == "ujson"
 Provides-Extra: test

gremlinpython-4.0.0.dev1.dist-info/RECORD

@@ -0,0 +1,33 @@
+gremlin_python/__init__.py,sha256=GlU7Dg8EuxYt0pBbBD1c7mk2-AUzaoVN05ZBl9UHoR4,879
+gremlin_python/statics.py,sha256=V8YHxJrE7M7JtgOSICMUbsOCu7bHk4n63fdFbbf8M1Q,4110
+gremlin_python/driver/__init__.py,sha256=g6RXUex0JTxx26nFwkID-1pxZN8qw-08ddWjeHrLd0Y,852
+gremlin_python/driver/auth.py,sha256=a7hWbx5yavb34mJpovJvIJQxMnvBmjcLTlc76E6EZDY,3226
+gremlin_python/driver/client.py,sha256=9tVwym-kESbhu-PcLLjMXv0h-3NvwyDSav6FkL9ypQE,8381
+gremlin_python/driver/connection.py,sha256=ADkFYdRbFHtNhc8oQDVFrMrB4ssZ21uXmgr1HogOHhY,8586
+gremlin_python/driver/driver_remote_connection.py,sha256=M_6WMFKd1WJww0hUOMMFn19IlGEWQGKSO-MxOCk2_FU,4814
+gremlin_python/driver/exceptions.py,sha256=z52kqnfepr8wHb9k-I2j3yBczmec6aU4YnTu3vWPlcg,1446
+gremlin_python/driver/http_request.py,sha256=uUG_PzwTbNSNJOdI7EdbY2fbEC6VzpHuXc_S0c7COXc,2332
+gremlin_python/driver/remote_connection.py,sha256=Q8iNH0Mp7y-yl_RdeQbpMZa3Q5Lbf3f8CmrAI_JdSVQ,2879
+gremlin_python/driver/request.py,sha256=UniNng8kxLO8W8cbqfHwpamu6YHwAqzkKLHWE-esEUI,1121
+gremlin_python/driver/resultset.py,sha256=wAMc_zhIw4vDIAmQXlJIKWf3660OG2ODWAupgUAEc7A,2421
+gremlin_python/driver/serializer.py,sha256=LIUErqUR1mhqFGPc5HUez-nWYEokITGhZfKE9TfI5b0,5271
+gremlin_python/driver/transaction.py,sha256=meoaLLZwSuCzt92H6w35v0NSN-uA4qRIsUlzBWL1QYg,6993
+gremlin_python/driver/useragent.py,sha256=LbXVrLUSEhhINxMUW9rU-hk2HQZHB9Uxw4-YqUvQtZw,1597
+gremlin_python/driver/aiohttp/__init__.py,sha256=Mnk4pWa5nTIrU_VYGdGJYftxPjA9MRZjFVYtvbDjH18,789
+gremlin_python/driver/aiohttp/transport.py,sha256=TkYUTwG-_KYxtA3FLpYUsiRChrrZCwVM5FE8dBm9Z2A,16091
+gremlin_python/process/__init__.py,sha256=g6RXUex0JTxx26nFwkID-1pxZN8qw-08ddWjeHrLd0Y,852
+gremlin_python/process/anonymous_traversal.py,sha256=VKJGNXxJ7nE8NShZLE3Cq7u35yB6KLwfatQSxnaNRVQ,2344
+gremlin_python/process/graph_traversal.py,sha256=gLsFNeV-hxgxPolyn9tV8sDng49uiO-l4ZFuvyq7yxQ,76339
+gremlin_python/process/strategies.py,sha256=lw7csIHrOUajzlEN_6YDRcIW27xXZ0kxw7SghHJJd28,10837
+gremlin_python/process/traversal.py,sha256=ufi5MG1UOpNihgIGxUmjzFpfwCa-WkjlLQgMh1pG2Ac,36215
+gremlin_python/structure/__init__.py,sha256=g6RXUex0JTxx26nFwkID-1pxZN8qw-08ddWjeHrLd0Y,852
+gremlin_python/structure/graph.py,sha256=TF_6JrqEKLem7Mw7gzflpaFNYCt4YK7MHu-ICHJWEkY,20233
+gremlin_python/structure/io/__init__.py,sha256=g6RXUex0JTxx26nFwkID-1pxZN8qw-08ddWjeHrLd0Y,852
+gremlin_python/structure/io/graphbinaryV4.py,sha256=0J1Ocm4PAdG_SIUwssYp1DbPPPjFKQyw6FSh8RCOZjQ,36717
+gremlin_python/structure/io/util.py,sha256=ysIZze-kLzR-DH-o-yJHk-bOulD0gjpUOuC2_OyBEdo,2801
+gremlinpython-4.0.0.dev1.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+gremlinpython-4.0.0.dev1.dist-info/licenses/NOTICE,sha256=FMjmoj_l2-AVGy2DCS85d0V5rk2A9R9ODI1qiWMJ0-Q,170
+gremlinpython-4.0.0.dev1.dist-info/METADATA,sha256=WzJ9WcELzcv_ujVVdNPSaq-IK02SW7JoiChkRpYcpGc,6913
+gremlinpython-4.0.0.dev1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+gremlinpython-4.0.0.dev1.dist-info/top_level.txt,sha256=VVeR1g-oOCZBmKIaVzZ7fF2BYrnqOWpw7C2H71ksTAU,15
+gremlinpython-4.0.0.dev1.dist-info/RECORD,,

{gremlinpython-4.0.0b2.dist-info → gremlinpython-4.0.0.dev1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gremlin_python/driver/protocol.py

@@ -1,175 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-import logging
-import abc
-
-log = logging.getLogger("gremlinpython")
-
-__author__ = 'David M. Brown (davebshow@gmail.com)'
-
-
-class GremlinServerError(Exception):
-    def __init__(self, status):
-        super(GremlinServerError, self).__init__('{0}: {1}'.format(status['code'], status['message']))
-        self.status_code = status['code']
-        self.status_message = status['message']
-        self.status_exception = status['exception']
-
-
-class ConfigurationError(Exception):
-    pass
-
-
-class AbstractBaseProtocol(metaclass=abc.ABCMeta):
-
-    @abc.abstractmethod
-    def connection_made(self, transport):
-        self._transport = transport
-
-    @abc.abstractmethod
-    def data_received(self, message, result_set):
-        pass
-
-    @abc.abstractmethod
-    def write(self, request_message):
-        pass
-
-
-class GremlinServerHTTPProtocol(AbstractBaseProtocol):
-
-    def __init__(self, request_serializer, response_serializer,
-                 interceptors=None, auth=None):
-        if callable(interceptors):
-            interceptors = [interceptors]
-        elif not (isinstance(interceptors, tuple)
-                  or isinstance(interceptors, list)
-                  or interceptors is None):
-            raise TypeError("interceptors must be a callable, tuple, list or None")
-
-        self._auth = auth
-        self._interceptors = interceptors
-        self._request_serializer = request_serializer
-        self._response_serializer = response_serializer
-        self._response_msg = {'status': {'code': 0,
-                                         'message': '',
-                                         'exception': ''},
-                              'result': {'meta': {},
-                                         'data': []}}
-        self._is_first_chunk = True
-
-    def connection_made(self, transport):
-        super(GremlinServerHTTPProtocol, self).connection_made(transport)
-
-    def write(self, request_message):
-        accept = str(self._response_serializer.version, encoding='utf-8')
-        message = {
-            'headers': {'accept': accept},
-            'payload': self._request_serializer.serialize_message(request_message)
-                if self._request_serializer is not None else request_message,
-            'auth': self._auth
-        }
-
-        # The user may not want the payload to be serialized if they are using an interceptor.
-        if self._request_serializer is not None:
-            content_type = str(self._request_serializer.version, encoding='utf-8')
-            message['headers']['content-type'] = content_type
-
-        for interceptor in self._interceptors or []:
-            message = interceptor(message)
-
-        self._transport.write(message)
-
-    '''
-    GraphSON does not support streaming deserialization, we are aggregating data and bypassing streamed
-     deserialization while GraphSON is enabled for testing. Remove after GraphSON is removed.
-    '''
-    def data_received_aggregate(self, response, result_set):
-        response_msg = {'status': {'code': 0,
-                                         'message': '',
-                                         'exception': ''},
-                              'result': {'meta': {},
-                                         'data': []}}
-
-        response_msg = self._decode_chunk(response_msg, response, self._is_first_chunk)
-
-        self._is_first_chunk = False
-        status_code = response_msg['status']['code']
-        aggregate_to = response_msg['result']['meta'].get('aggregateTo', 'list')
-        data = response_msg['result']['data']
-        result_set.aggregate_to = aggregate_to
-        self._is_first_chunk = True
-
-        if status_code == 204 and len(data) == 0:
-            result_set.stream.put_nowait([])
-        elif status_code in [200, 204, 206]:
-            result_set.stream.put_nowait(data)
-        else:
-            log.error("\r\nReceived error message '%s'\r\n\r\nWith result set '%s'",
-                      str(self._response_msg), str(result_set))
-            raise GremlinServerError({'code': status_code,
-                                        'message': self._response_msg['status']['message'],
-                                        'exception': self._response_msg['status']['exception']})
-
-    # data is received in chunks
-    def data_received(self, response_chunk, result_set, read_completed=None, http_req_resp=None):
-        # we shouldn't need to use the http_req_resp code as status is sent in response message, but leaving it for now
-        if read_completed:
-            status_code = self._response_msg['status']['code']
-            aggregate_to = self._response_msg['result']['meta'].get('aggregateTo', 'list')
-            data = self._response_msg['result']['data']
-            result_set.aggregate_to = aggregate_to
-
-            # reset response message
-            self._response_msg = {'status': {'code': 0,
-                                             'message': '',
-                                             'exception': ''},
-                                  'result': {'meta': {},
-                                             'data': []}}
-            self._is_first_chunk = True
-
-            if status_code == 204 and len(data) == 0:
-                result_set.stream.put_nowait([])
-            elif status_code in [200, 204, 206]:
-                result_set.stream.put_nowait(data)
-            else:
-                log.error("\r\nReceived error message '%s'\r\n\r\nWith result set '%s'",
-                          str(self._response_msg), str(result_set))
-                raise GremlinServerError({'code': status_code,
-                                          'message': self._response_msg['status']['message'],
-                                          'exception': self._response_msg['status']['exception']})
-        else:
-            self._response_msg = self._decode_chunk(self._response_msg, response_chunk, self._is_first_chunk)
-            self._is_first_chunk = False
-
-    def _decode_chunk(self, message, data_buffer, is_first_chunk):
-        chunk_msg = self._response_serializer.deserialize_message(data_buffer, is_first_chunk)
-
-        if 'result' in chunk_msg:
-            msg_data = message['result']['data']
-            chunk_data = chunk_msg['result']['data']
-            message['result']['data'] = [*msg_data, *chunk_data]
-        if 'status' in chunk_msg:
-            status_code = chunk_msg['status']['code']
-            if status_code in [200, 204, 206]:
-                message.update({'status': chunk_msg['status']})
-            else:
-                raise GremlinServerError({'code': status_code,
-                                          'message': chunk_msg['status']['message'],
-                                          'exception': chunk_msg['status']['exception']})
-        return message