gremlinpython 3.6.5__py2.py3-none-any.whl → 3.6.6__py2.py3-none-any.whl

gremlin_python/__version__.py

@@ -16,5 +16,5 @@ KIND, either express or implied.  See the License for the
 specific language governing permissions and limitations
 under the License.
 '''
-version   = '3.6.5'
-timestamp = 1691177118
+version   = '3.6.6'
+timestamp = 1701718721

gremlin_python/driver/aiohttp/transport.py

@@ -138,3 +138,99 @@ class AiohttpTransport(AbstractBaseTransport):
     def closed(self):
         # Connection is closed if either the websocket or the client session is closed.
         return self._websocket.closed or self._client_session.closed
+
+
+class AiohttpHTTPTransport(AbstractBaseTransport):
+    nest_asyncio_applied = False
+
+    def __init__(self, call_from_event_loop=None, read_timeout=None, write_timeout=None, **kwargs):
+        if call_from_event_loop is not None and call_from_event_loop and not AiohttpTransport.nest_asyncio_applied:
+            """ 
+                The AiohttpTransport implementation uses the asyncio event loop. Because of this, it cannot be called 
+                within an event loop without nest_asyncio. If the code is ever refactored so that it can be called 
+                within an event loop this import and call can be removed. Without this, applications which use the 
+                event loop to call gremlin-python (such as Jupyter) will not work.
+            """
+            import nest_asyncio
+            nest_asyncio.apply()
+            AiohttpTransport.nest_asyncio_applied = True
+
+        # Start event loop and initialize client session and response to None
+        self._loop = asyncio.new_event_loop()
+        self._client_session = None
+        self._http_req_resp = None
+        self._enable_ssl = False
+
+        # Set all inner variables to parameters passed in.
+        self._aiohttp_kwargs = kwargs
+        self._write_timeout = write_timeout
+        self._read_timeout = read_timeout
+        if "ssl_options" in self._aiohttp_kwargs:
+            self._ssl_context = self._aiohttp_kwargs.pop("ssl_options")
+            self._enable_ssl = True
+
+    def __del__(self):
+        # Close will only actually close if things are left open, so this is safe to call.
+        # Clean up any connection resources and close the event loop.
+        self.close()
+
+    def connect(self, url, headers=None):
+        # Inner function to perform async connect.
+        async def async_connect():
+            # Start client session and use it to send all HTTP requests. Base url is the endpoint, headers are set here
+            # Base url can only parse basic url with no path, see https://github.com/aio-libs/aiohttp/issues/6647
+            if self._enable_ssl:
+                # ssl context is established through tcp connector
+                tcp_conn = aiohttp.TCPConnector(ssl_context=self._ssl_context)
+                self._client_session = aiohttp.ClientSession(connector=tcp_conn,
+                                                             base_url=url, headers=headers, loop=self._loop)
+            else:
+                self._client_session = aiohttp.ClientSession(base_url=url, headers=headers, loop=self._loop)
+
+        # Execute the async connect synchronously.
+        self._loop.run_until_complete(async_connect())
+
+    def write(self, message):
+        # Inner function to perform async write.
+        async def async_write():
+            basic_auth = None
+            # basic password authentication for https connections
+            if message['auth']:
+                basic_auth = aiohttp.BasicAuth(message['auth']['username'], message['auth']['password'])
+            async with async_timeout.timeout(self._write_timeout):
+                self._http_req_resp = await self._client_session.post(url="/gremlin",
+                                                                      auth=basic_auth,
+                                                                      data=message['payload'],
+                                                                      headers=message['headers'],
+                                                                      **self._aiohttp_kwargs)
+
+        # Execute the async write synchronously.
+        self._loop.run_until_complete(async_write())
+
+    def read(self):
+        # Inner function to perform async read.
+        async def async_read():
+            async with async_timeout.timeout(self._read_timeout):
+                return await self._http_req_resp.read()
+
+        return self._loop.run_until_complete(async_read())
+
+    def close(self):
+        # Inner function to perform async close.
+        async def async_close():
+            if self._client_session is not None and not self._client_session.closed:
+                await self._client_session.close()
+                self._client_session = None
+
+        # If the loop is not closed (connection hasn't already been closed)
+        if not self._loop.is_closed():
+            # Execute the async close synchronously.
+            self._loop.run_until_complete(async_close())
+
+            # Close the event loop.
+            self._loop.close()
+
+    @property
+    def closed(self):
+        # Connection is closed when client session is closed.
+        return self._client_session.closed

gremlin_python/driver/client.py

@@ -19,6 +19,7 @@
 import logging
 import warnings
 import queue
+import re
 from concurrent.futures import ThreadPoolExecutor
 
 from gremlin_python.driver import connection, protocol, request, serializer
@@ -45,12 +46,16 @@ class Client:
                  kerberized_service="", headers=None, session=None,
                  enable_user_agent_on_connect=True, **transport_kwargs):
         log.info("Creating Client with url '%s'", url)
+
+        # check via url that we are using http protocol
+        self._use_http = re.search('^http', url)
+
         self._closed = False
         self._url = url
         self._headers = headers
         self._enable_user_agent_on_connect = enable_user_agent_on_connect
         self._traversal_source = traversal_source
-        if "max_content_length" not in transport_kwargs:
+        if not self._use_http and "max_content_length" not in transport_kwargs:
             transport_kwargs["max_content_length"] = 10 * 1024 * 1024
         if message_serializer is None:
             message_serializer = serializer.GraphBinarySerializersV1()
@@ -63,21 +68,31 @@ class Client:
         if transport_factory is None:
             try:
                 from gremlin_python.driver.aiohttp.transport import (
-                    AiohttpTransport)
+                    AiohttpTransport, AiohttpHTTPTransport)
             except ImportError:
                 raise Exception("Please install AIOHTTP or pass "
                                 "custom transport factory")
             else:
                 def transport_factory():
-                    return AiohttpTransport(**transport_kwargs)
+                    if self._use_http:
+                        return AiohttpHTTPTransport(**transport_kwargs)
+                    else:
+                        return AiohttpTransport(**transport_kwargs)
         self._transport_factory = transport_factory
         if protocol_factory is None:
-            def protocol_factory(): return protocol.GremlinServerWSProtocol(
-                self._message_serializer,
-                username=self._username,
-                password=self._password,
-                kerberized_service=kerberized_service,
-                max_content_length=transport_kwargs["max_content_length"])
+            def protocol_factory():
+                if self._use_http:
+                    return protocol.GremlinServerHTTPProtocol(
+                        self._message_serializer,
+                        username=self._username,
+                        password=self._password)
+                else:
+                    return protocol.GremlinServerWSProtocol(
+                        self._message_serializer,
+                        username=self._username,
+                        password=self._password,
+                        kerberized_service=kerberized_service,
+                        max_content_length=transport_kwargs["max_content_length"])
         self._protocol_factory = protocol_factory
         if self._session_enabled:
             if pool_size is None:

gremlin_python/driver/connection.py

@@ -61,6 +61,7 @@ class Connection:
         request_id = str(uuid.uuid4())
         if request_message.args.get("requestId"):
             request_id = request_message.args.get("requestId")
+            uuid.UUID(request_id) # Checks for proper UUID or else server will return an error.
         result_set = resultset.ResultSet(queue.Queue(), request_id)
         self._results[request_id] = result_set
         # Create write task

gremlin_python/driver/protocol.py

@@ -16,6 +16,7 @@
 # specific language governing permissions and limitations
 # under the License.
 #
+import json
 import logging
 import abc
 import base64
@@ -25,6 +26,8 @@ import struct
 
 from gremlin_python.driver import request
 from gremlin_python.driver.resultset import ResultSet
+from gremlin_python.process.translator import Translator
+from gremlin_python.process.traversal import Bytecode
 
 log = logging.getLogger("gremlinpython")
 
@@ -63,7 +66,6 @@ class AbstractBaseProtocol(metaclass=abc.ABCMeta):
 
 
 class GremlinServerWSProtocol(AbstractBaseProtocol):
-
     QOP_AUTH_BIT = 1
     _kerberos_context = None
     _max_content_length = 10 * 1024 * 1024
@@ -133,7 +135,7 @@ class GremlinServerWSProtocol(AbstractBaseProtocol):
             # This message is going to be huge and kind of hard to read, but in the event of an error,
             # it can provide invaluable info, so space it out appropriately.
             log.error("\r\nReceived error message '%s'\r\n\r\nWith results dictionary '%s'",
-                          str(message), str(results_dict))
+                      str(message), str(results_dict))
             del results_dict[request_id]
             raise GremlinServerError(message['status'])
 
@@ -185,8 +187,71 @@ class GremlinServerWSProtocol(AbstractBaseProtocol):
         name_length = len(self._username)
         fmt = '!I' + str(name_length) + 's'
         word = self.QOP_AUTH_BIT << 24 | self._max_content_length
-        out = struct.pack(fmt, word, self._username.encode("utf-8"),)
+        out = struct.pack(fmt, word, self._username.encode("utf-8"), )
         encoded = base64.b64encode(out).decode('ascii')
         kerberos.authGSSClientWrap(self._kerberos_context, encoded)
         auth = kerberos.authGSSClientResponse(self._kerberos_context)
         return request.RequestMessage('', 'authentication', {'sasl': auth})
+
+
+class GremlinServerHTTPProtocol(AbstractBaseProtocol):
+
+    def __init__(self,
+                 message_serializer,
+                 username='', password=''):
+        self._message_serializer = message_serializer
+        self._username = username
+        self._password = password
+
+    def connection_made(self, transport):
+        super(GremlinServerHTTPProtocol, self).connection_made(transport)
+
+    def write(self, request_id, request_message):
+
+        basic_auth = {}
+        if self._username and self._password:
+            basic_auth['username'] = self._username
+            basic_auth['password'] = self._password
+
+        content_type = str(self._message_serializer.version, encoding='utf-8')
+        message = {
+            'headers': {'CONTENT-TYPE': content_type,
+                        'ACCEPT': content_type},
+            'payload': self._message_serializer.serialize_message(request_id, request_message),
+            'auth': basic_auth
+        }
+
+        self._transport.write(message)
+
+    def data_received(self, message, results_dict):
+        # if Gremlin Server cuts off then we get a None for the message
+        if message is None:
+            log.error("Received empty message from server.")
+            raise GremlinServerError({'code': 500,
+                                      'message': 'Server disconnected - please try to reconnect', 'attributes': {}})
+
+        message = self._message_serializer.deserialize_message(message)
+        request_id = message['requestId']
+        result_set = results_dict[request_id] if request_id in results_dict else ResultSet(None, None)
+        status_code = message['status']['code']
+        aggregate_to = message['result']['meta'].get('aggregateTo', 'list')
+        data = message['result']['data']
+        result_set.aggregate_to = aggregate_to
+
+        if status_code == 204:
+            result_set.stream.put_nowait([])
+            del results_dict[request_id]
+            return status_code
+        elif status_code in [200, 206]:
+            result_set.stream.put_nowait(data)
+            if status_code == 200:
+                result_set.status_attributes = message['status']['attributes']
+                del results_dict[request_id]
+            return status_code
+        else:
+            # This message is going to be huge and kind of hard to read, but in the event of an error,
+            # it can provide invaluable info, so space it out appropriately.
+            log.error("\r\nReceived error message '%s'\r\n\r\nWith results dictionary '%s'",
+                      str(message), str(results_dict))
+            del results_dict[request_id]
+            raise GremlinServerError(message['status'])

gremlin_python/driver/serializer.py

@@ -17,6 +17,7 @@
 # under the License.
 #
 
+import base64
 import logging
 import struct
 import uuid
@@ -156,7 +157,8 @@ class GraphSONMessageSerializer(object):
         return message
 
     def deserialize_message(self, message):
-        msg = json.loads(message.decode('utf-8'))
+        # for parsing string message via HTTP connections
+        msg = json.loads(message if isinstance(message, str) else message.decode('utf-8'))
         return self._graphson_reader.to_object(msg)
 
 
@@ -268,7 +270,8 @@ class GraphBinarySerializersV1(object):
         return bytes(ba)
 
     def deserialize_message(self, message):
-        b = io.BytesIO(message)
+        # for parsing string message via HTTP connections
+        b = io.BytesIO(base64.b64decode(message) if isinstance(message, str) else message)
 
         b.read(1)  # version
 

gremlin_python/driver/useragent.py

@@ -18,7 +18,7 @@
 #
 import platform
 
-gremlin_version = "3.6.5"  # DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
+gremlin_version = "3.6.6"  # DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
 
 def _generate_user_agent():
     application_name = "NotAvailable"

gremlin_python/process/translator.py

@@ -24,11 +24,13 @@ sent to any TinkerPop compliant HTTP endpoint.
 """
 __author__ = 'Kelvin R. Lawrence (gfxman)'
 
-from gremlin_python.process.graph_traversal import __
-from gremlin_python.process.anonymous_traversal import traversal
+import math
+import numbers
+import re
+
 from gremlin_python.process.traversal import *
-from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
 from gremlin_python.process.strategies import *
+from gremlin_python.structure.graph import Vertex, Edge, VertexProperty
 from datetime import datetime
 
 
@@ -39,18 +41,20 @@ class Translator:
 
     # Dictionary used to reverse-map token IDs to strings
     options = {
-      WithOptions.tokens: 'tokens',
-      WithOptions.none: 'none',
-      WithOptions.ids: 'ids',
-      WithOptions.labels: 'labels',
-      WithOptions.keys: 'keys',
-      WithOptions.values: 'values',
-      WithOptions.all: 'all',
-      WithOptions.indexer: 'indexer',
-      WithOptions.list: 'list',
-      WithOptions.map: 'map'                           
+        WithOptions.tokens: 'tokens',
+        WithOptions.none: 'none',
+        WithOptions.ids: 'ids',
+        WithOptions.labels: 'labels',
+        WithOptions.keys: 'keys',
+        WithOptions.values: 'values',
+        WithOptions.all: 'all',
+        WithOptions.indexer: 'indexer',
+        WithOptions.list: 'list',
+        WithOptions.map: 'map'
     }
 
+    conn_p = ['and', 'or']
+
     def __init__(self, traversal_source=None):
         self.traversal_source = traversal_source
 
@@ -60,20 +64,37 @@ class Translator:
     def get_target_language(self):
         return "gremlin-groovy"
 
-    def of(self,traversal_source):
+    def of(self, traversal_source):
         self.traversal_source = traversal_source
         return self
 
     # Do any needed special processing for the representation
-    # of strings and dates.
+    # of strings and dates and boolean.
     def fixup(self, v):
         if isinstance(v, str):
-            return f'\'{v}\''
+            return f'{v!r}'  # use repr() format for canonical string rep
         elif type(v) == datetime:
             return self.process_date(v)
+        elif type(v) == bool:
+            return 'true' if v else 'false'
+        elif isinstance(v, numbers.Number):
+            return self.process_number(v)
+        elif isinstance(v, set):
+            return f'[{str(v)[1:-1]}]'
+        elif isinstance(v, P):
+            return self.process_predicate(v)
+        elif type(v) == Vertex:
+            return self.process_vertex(v)
+        elif type(v) == Edge:
+            return self.process_edge(v)
+        elif type(v) in [Merge]:  # on_create on_match out_v in_v
+            tmp = str(v)
+            return f'{tmp.split("_")[0]}{tmp.split("_")[1].capitalize()}' if tmp.find('_') else tmp
+        elif v is None:
+            return 'null'
         else:
             return str(v)
-    
+
     # Turn a Python datetime into the equivalent new Date(...)
     def process_date(self, date):
         y = date.year - 1900
@@ -87,36 +108,113 @@ class Translator:
     # Do special processing needed to format predicates that come in
     # such as "gt(a)" correctly.
     def process_predicate(self, p):
-        res = str(p).split('(')[0] + '('
+        res = ''
+        if p.operator in self.conn_p:
+            res += f'{self.process_predicate(p.value)}.{p.operator}({self.process_predicate(p.other)})'
+        else:
+            res += f'{self.process_p_value(p)}'
+        return res
 
+    # process the value of the predicates
+    def process_p_value(self, p):
+        res = str(p).split('(')[0] + '('
         if type(p.value) == list:
             res += '['
             for v in p.value:
                 res += self.fixup(v) + ','
-            res = res[0:-1] + ']'
+            res = (res[0:-1] + ']') if len(p.value) > 0 else (res + ']')
         else:
             res += self.fixup(p.value)
             if p.other is not None:
-                res+= ',' + self.fixup(p.other)
+                res += f',{self.fixup(p.other)}'
         res += ')'
         return res
 
     # Special processing to handle strategies
     def process_strategy(self, s):
         c = 0
-        res = f'new {str(s)}('
-        for key in s.configuration:
-            res += ',' if c > 0 else ''
-            res += key + ':'
-            val = s.configuration[key]
-            if isinstance(val, Traversal):
-                res += self.translate(val.bytecode, child=True)
+        res = ''
+        # if parameter is empty, only pass class name (referenced GroovyTranslator.java)
+        if not s.configuration:
+            res += s.strategy_name
+        else:
+            res = f'new {str(s)}('
+            for key in s.configuration:
+                res += ',' if c > 0 else ''
+                res += key + ':'
+                val = s.configuration[key]
+                if isinstance(val, Traversal):
+                    res += self.translate(val.bytecode, child=True)
+                else:
+                    res += self.fixup(val)
+                c += 1
+            res += ')'
+        return res
+        pass
+
+    # Special processing to handle vertices
+    def process_vertex(self, vertex):
+        return f'new ReferenceVertex({self.fixup(vertex.id)},\'{vertex.label}\')'
+
+    # Special processing to handle edges
+    def process_edge(self, edge):
+        return f'new ReferenceEdge({str(edge.id)},\'{edge.label}\',' \
+               f'new ReferenceVertex({str(edge.inV.id)},\'{edge.inV.label}\'),' \
+               f'new ReferenceVertex({str(edge.outV.id)},\'{edge.outV.label}\'))'
+
+    # Special processing to handle vertex property
+    def process_vertex_property(self, vp):
+        return f'new ReferenceVertexProperty({str(vp.id)},\'{vp.label}\',{self.fixup(vp.value)})'
+
+    # Special processing to handle lambda
+    def process_lambda(self, lam):
+        lambda_result = lam()
+        script = lambda_result if isinstance(lambda_result, str) else lambda_result[0]
+        return f'{script}' if re.match(r"^\{.*\}$", script, flags=re.DOTALL) else f'{{{script}}}'
+
+    def process_dict(self, d):
+        c = 0
+        res = '['
+        if len(d) == 0:
+            res += ':'
+        else:
+            for k, v in d.items():
+                wrap = not isinstance(k, str)
+                res += ',' if c > 0 else ''
+                res += '(' if wrap else ''
+                res += self.fixup(k)
+                res += ')' if wrap else ''
+                res += f':{self.fixup(v)}'
+                c += 1
+        res += ']'
+        return res
+
+    def process_number(self, n):
+        if isinstance(n, float):
+            # converting floats into doubles for script since python doesn't distinguish and java defaults to double
+            if math.isnan(n):
+                return "Double.NaN"
+            elif math.isinf(n) and n > 0:
+                return "Double.POSITIVE_INFINITY"
+            elif math.isinf(n) and n < 0:
+                return "Double.NEGATIVE_INFINITY"
             else:
-                res += self.fixup(val)
+                return f'{n}d'
+        return f'{n}'
+
+    def process_list(self, l):
+        c = 0
+        res = '['
+        for i in l:
+            res += ',' if c > 0 else ''
+            res += self.fixup(i)
             c += 1
-        res += ')'
+        res += ']'
         return res
-        pass
+
+    # Special processing to handle bindings inside of traversals
+    def process_binding(self, binding):
+        return f'Bindings.instance().of(\'{binding.key}\', {str(binding.value)})'
 
     # Main driver of the translation. Different parts of
     # a Traversal are handled appropriately.
@@ -127,19 +225,29 @@ class Translator:
         if len(params) > 0:
             c = 0
             with_opts = False
+            is_merge_op = (step[0] == 'mergeV') or (step[0] == 'mergeE')
             for p in params:
                 script += ',' if c > 0 else ''
                 if with_opts:
-                  script += f'WithOptions.{self.options[p]}'
+                    script += f'WithOptions.{self.options[p]}'
                 elif type(p) == Bytecode:
                     script += self.translate(p, True)
                 elif isinstance(p, P):
                     script += self.process_predicate(p)
-                elif type(p) in [Cardinality, Pop, Operator]:
+                elif type(p) == Vertex:
+                    script += self.process_vertex(p)
+                elif type(p) == Edge:
+                    script += self.process_edge(p)
+                elif type(p) == VertexProperty:
+                    script += self.process_vertex_property(p)
+                elif type(p) in [Cardinality, Pop, Operator, Scope, T]:
+                    tmp = str(p)
+                    script += tmp[0:-1] if tmp.endswith('_') else tmp
+                elif type(p) in [Merge]:  # on_create on_match out_v in_v
+                    is_merge_op = True
                     tmp = str(p)
-                    script += tmp[0:-1] if tmp.endswith('_') else tmp 
-                elif type(p) in [ReadOnlyStrategy, SubgraphStrategy, VertexProgramStrategy,
-                                 OptionsStrategy, PartitionStrategy]:
+                    script += f'{tmp.split("_")[0]}{tmp.split("_")[1].capitalize()}' if tmp.find('_') else tmp
+                elif isinstance(p, TraversalStrategy):  # this will capture all strategies
                     script += self.process_strategy(p)
                 elif type(p) == datetime:
                     script += self.process_date(p)
@@ -147,11 +255,25 @@ class Translator:
                     script += 'WithOptions.tokens'
                     with_opts = True
                 elif isinstance(p, str):
-                    script += f'\'{p}\''
+                    script += f'{p!r}'  # use repr() format for canonical string rep
                 elif type(p) == bool:
                     script += 'true' if p else 'false'
+                elif isinstance(p, type(lambda: None)) and p.__name__ == (lambda: None).__name__:
+                    script += self.process_lambda(p)
+                elif type(p) == Binding:
+                    script += self.process_binding(p)
                 elif p is None:
-                    script += 'null'
+                    script += '(Traversal) null' if is_merge_op else 'null'
+                elif isinstance(p, type):
+                    script += p.__name__
+                elif isinstance(p, dict):
+                    script += self.process_dict(p)
+                elif isinstance(p, numbers.Number):
+                    script += self.process_number(p)
+                elif isinstance(p, set):
+                    script += f'[{str(p)[1:-1]}] as Set' if len(p) > 0 else '[] as Set'
+                elif isinstance(p, list):
+                    script += self.process_list(p)
                 else:
                     script += str(p)
                 c += 1
@@ -165,11 +287,11 @@ class Translator:
     # anonymous traversal style syntax.
     def translate(self, bytecode, child=False):
         script = '__' if child else self.traversal_source
-        
+
         for step in bytecode.source_instructions:
             script += self.do_translation(step)
 
         for step in bytecode.step_instructions:
             script += self.do_translation(step)
-       
+
         return script

{gremlinpython-3.6.5.dist-info → gremlinpython-3.6.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gremlinpython
-Version: 3.6.5
+Version: 3.6.6
 Summary: Gremlin-Python for Apache TinkerPop
 Home-page: http://tinkerpop.apache.org
 License: Apache 2

{gremlinpython-3.6.5.dist-info → gremlinpython-3.6.6.dist-info}/RECORD

@@ -1,24 +1,24 @@
 gremlin_python/__init__.py,sha256=rbOOdo_19nz_mHTXVc5p8ZXLI5pUGMfXLKQiw7Olu7g,850
-gremlin_python/__version__.py,sha256=0ziu1yIjAcHDwuwTnKTPaUR9LVforR8SYbIrFTwGNjg,804
+gremlin_python/__version__.py,sha256=y0xEAtZ4-6wJeqieWTyT_bc2McYCIlmtqGOAnUvysno,804
 gremlin_python/statics.py,sha256=BXnrfx25Todku_U0ddd-zB4eyQMf2paT5uuN9znK2fQ,2849
 gremlin_python/driver/__init__.py,sha256=rbOOdo_19nz_mHTXVc5p8ZXLI5pUGMfXLKQiw7Olu7g,850
-gremlin_python/driver/client.py,sha256=HJZmYGsxb4tzVmEfM3QQGuqK--kxmcd0Y255pBo6-Rc,7399
-gremlin_python/driver/connection.py,sha256=LKrslNCXf5Gu8um1b2pBiZ84zKZ_HsJ-dQh4DouDd-U,3395
+gremlin_python/driver/client.py,sha256=D5JfgxOBvOkZZX10CZ_uVbA14Ez2SW_nWl7gRXrd7qw,8030
+gremlin_python/driver/connection.py,sha256=m_wjluA1tv30s7X9LhDi4GgPMCB4nMcDHHXxMA58z2E,3491
 gremlin_python/driver/driver_remote_connection.py,sha256=YK4_se8Md57Dq-P6VwcLag0vH-AOoGqayQA9suG-_fM,8670
-gremlin_python/driver/protocol.py,sha256=LmzvTMjQEmRd2GRWN2CSishbtOKvD11376wZ2Todpe4,8746
+gremlin_python/driver/protocol.py,sha256=s-TC8iRlcYmO7iNk6RQW0SttO9nIOfUBkj0h9mwqwPA,11549
 gremlin_python/driver/remote_connection.py,sha256=DtglObhiyLDIgLKIcv7enDuXd9KiCJVLXWAvreBQ4wA,3014
 gremlin_python/driver/request.py,sha256=IlqBmQlT2UU95xbY6z1ajlmNQeDZ4ePzT4uF8M0USFk,953
 gremlin_python/driver/resultset.py,sha256=_-13igfH1zQ72mgreDptPmUaXnadnprERVQTSZWeIl4,2669
-gremlin_python/driver/serializer.py,sha256=dMKXL9YYFK2DJKQfIQ2Y-R-_DoyqjRBSPTn4k5SID0M,10009
+gremlin_python/driver/serializer.py,sha256=e__rrMw3p74RoGl4Hh1zsDw2XFyRihfuNu7GuTK_E4E,10239
 gremlin_python/driver/transport.py,sha256=aEXb9oS1SMI9oKWYINnWuYhYaosi6FdsOJ7oj6FzkkY,1246
-gremlin_python/driver/useragent.py,sha256=zBm9UgIIUtnZH0IzF8_40aWKa5ATii37_Q7wSkLciuc,1588
+gremlin_python/driver/useragent.py,sha256=ynpcC4TFcDc2aFuTJc7bX9HdJRK0Req6kci8K2u03TA,1588
 gremlin_python/driver/aiohttp/__init__.py,sha256=xzdixoKYCJCe4aRILYqdartQi4Py5fcQWqif3zzyUC8,787
-gremlin_python/driver/aiohttp/transport.py,sha256=qKSvgWZw8Gv2OYnriycphs2Nb2zoaw2tPzol0aMtp3Q,6228
+gremlin_python/driver/aiohttp/transport.py,sha256=x2jmwkHTM8BTxGBqyfwncyh9jgi0CUxSgGqPCRW6aCo,10842
 gremlin_python/process/__init__.py,sha256=rbOOdo_19nz_mHTXVc5p8ZXLI5pUGMfXLKQiw7Olu7g,850
 gremlin_python/process/anonymous_traversal.py,sha256=A8evyPIAciRGiauDqUbyo4XnG3QTdO28l-TF2K7Ir2g,2448
 gremlin_python/process/graph_traversal.py,sha256=XDTC1rcKe0FcqUrchqPVRUnoTkYTa2xVY-dH3c7BSCw,61092
 gremlin_python/process/strategies.py,sha256=95WIhzvvqejCEDOlhICGji9HgkwTUySGKt-yNCBTTh8,9474
-gremlin_python/process/translator.py,sha256=wQUFDmex8g7paYfUreWKhTY3bUnM0nF4bnZOm6H2zbs,6159
+gremlin_python/process/translator.py,sha256=NuaA2WfepvgDm3DrNa_u2Qvz70s9t6ICbFltPglQwBI,11147
 gremlin_python/process/traversal.py,sha256=kt_2HlRTIvMEnkOR9654eAJESP4bcMFt9BfWlKjQgu8,22451
 gremlin_python/structure/__init__.py,sha256=zo5zR3kruv1h4_A80IxZ1IZrS0Ud5lVjpGm0PxBAP20,852
 gremlin_python/structure/graph.py,sha256=JdyP2yiZKK2EnkTn4wIiy-bZb8iGLCvneC8T_VaZgvo,4365
@@ -27,11 +27,11 @@ gremlin_python/structure/io/graphbinaryV1.py,sha256=Ti_eR70jOmJnapiyTq1qhkt90CKf
 gremlin_python/structure/io/graphsonV2d0.py,sha256=t63IZ6UIVngvQcH8fnnLDmWm0KoCuDrwB5lprM2dFuw,20598
 gremlin_python/structure/io/graphsonV3d0.py,sha256=bEiZcJduPNGmf5rHdl0Yq9QFwAmnvADDBytmBAAirQM,23918
 gremlin_python/structure/io/util.py,sha256=x0OEkGGX2ajgOuSbz1j3dO3_IlOPnPLV4m6SGAmNAeM,1846
-gremlinpython-3.6.5.data/data/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-gremlinpython-3.6.5.data/data/NOTICE,sha256=cQwbCsygJy_LcRskXIJSOhUxEZWiR_QM6xpJCS1v0_o,170
-gremlinpython-3.6.5.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-gremlinpython-3.6.5.dist-info/METADATA,sha256=zCuAXXMo6jPGSIPzmUdh39F4bKGvUQLbD9D1lY93C0w,6351
-gremlinpython-3.6.5.dist-info/NOTICE,sha256=cQwbCsygJy_LcRskXIJSOhUxEZWiR_QM6xpJCS1v0_o,170
-gremlinpython-3.6.5.dist-info/WHEEL,sha256=k3vXr0c0OitO0k9eCWBlI2yTYnpb_n_I2SGzrrfY7HY,110
-gremlinpython-3.6.5.dist-info/top_level.txt,sha256=VVeR1g-oOCZBmKIaVzZ7fF2BYrnqOWpw7C2H71ksTAU,15
-gremlinpython-3.6.5.dist-info/RECORD,,
+gremlinpython-3.6.6.data/data/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+gremlinpython-3.6.6.data/data/NOTICE,sha256=cQwbCsygJy_LcRskXIJSOhUxEZWiR_QM6xpJCS1v0_o,170
+gremlinpython-3.6.6.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+gremlinpython-3.6.6.dist-info/METADATA,sha256=mhEIUOdF3PaNFw-nMo_5jv3o3BfEJTcvTo5qV3jzo0g,6351
+gremlinpython-3.6.6.dist-info/NOTICE,sha256=cQwbCsygJy_LcRskXIJSOhUxEZWiR_QM6xpJCS1v0_o,170
+gremlinpython-3.6.6.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
+gremlinpython-3.6.6.dist-info/top_level.txt,sha256=VVeR1g-oOCZBmKIaVzZ7fF2BYrnqOWpw7C2H71ksTAU,15
+gremlinpython-3.6.6.dist-info/RECORD,,

{gremlinpython-3.6.5.dist-info → gremlinpython-3.6.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.0)
+Generator: bdist_wheel (0.37.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any