gremlinpython 3.6.5__tar.gz → 3.6.6__tar.gz

{gremlinpython-3.6.5/gremlinpython.egg-info → gremlinpython-3.6.6}/PKG-INFO

@@ -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 → gremlinpython-3.6.6}/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

{gremlinpython-3.6.5 → gremlinpython-3.6.6}/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

{gremlinpython-3.6.5 → gremlinpython-3.6.6}/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:

{gremlinpython-3.6.5 → gremlinpython-3.6.6}/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

{gremlinpython-3.6.5 → gremlinpython-3.6.6}/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'])

{gremlinpython-3.6.5 → gremlinpython-3.6.6}/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
 

{gremlinpython-3.6.5 → gremlinpython-3.6.6}/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"

gremlinpython-3.6.6/gremlin_python/process/translator.py

@@ -0,0 +1,297 @@
+#
+# 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.
+#
+
+"""
+Class that can turn traversals back into Gremlin Groovy format text queries.
+Those queries can then be run in the Gremlin console or using the GLV submit(<String>) API or
+sent to any TinkerPop compliant HTTP endpoint.
+"""
+__author__ = 'Kelvin R. Lawrence (gfxman)'
+
+import math
+import numbers
+import re
+
+from gremlin_python.process.traversal import *
+from gremlin_python.process.strategies import *
+from gremlin_python.structure.graph import Vertex, Edge, VertexProperty
+from datetime import datetime
+
+
+class Translator:
+    """
+    Turn a bytecode object back into a textual query (Gremlin Groovy script).
+    """
+
+    # 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'
+    }
+
+    conn_p = ['and', 'or']
+
+    def __init__(self, traversal_source=None):
+        self.traversal_source = traversal_source
+
+    def get_traversal_source(self):
+        return self.traversal_source
+
+    def get_target_language(self):
+        return "gremlin-groovy"
+
+    def of(self, traversal_source):
+        self.traversal_source = traversal_source
+        return self
+
+    # Do any needed special processing for the representation
+    # of strings and dates and boolean.
+    def fixup(self, v):
+        if isinstance(v, str):
+            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
+        mo = date.month
+        d = date.day
+        h = date.hour
+        mi = date.minute
+        s = date.second
+        return f'new Date({y},{mo},{d},{h},{mi},{s})'
+
+    # Do special processing needed to format predicates that come in
+    # such as "gt(a)" correctly.
+    def process_predicate(self, p):
+        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] + ']') if len(p.value) > 0 else (res + ']')
+        else:
+            res += self.fixup(p.value)
+            if p.other is not None:
+                res += f',{self.fixup(p.other)}'
+        res += ')'
+        return res
+
+    # Special processing to handle strategies
+    def process_strategy(self, s):
+        c = 0
+        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:
+                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 += ']'
+        return res
+
+    # 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.
+    def do_translation(self, step):
+        script = ''
+        params = step[1:]
+        script += '.' + step[0] + '('
+        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]}'
+                elif type(p) == Bytecode:
+                    script += self.translate(p, True)
+                elif isinstance(p, P):
+                    script += self.process_predicate(p)
+                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 += 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)
+                elif p == WithOptions.tokens:
+                    script += 'WithOptions.tokens'
+                    with_opts = True
+                elif isinstance(p, str):
+                    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 += '(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
+        script += ')'
+        return script
+
+    # Translation starts here. There are two main parts to a 
+    # traversal. Source instructions such as "withSideEffect"
+    # and "withStrategies", and step instructions such as 
+    # "addV" and "repeat". If child is True we will generate
+    # 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 → gremlinpython-3.6.6/gremlinpython.egg-info}/PKG-INFO

@@ -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/gremlin_python/process/translator.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.
-#
-
-"""
-Class that can turn traversals back into Gremlin Groovy format text queries.
-Those queries can then be run in the Gremlin console or using the GLV submit(<String>) API or
-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
-from gremlin_python.process.traversal import *
-from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
-from gremlin_python.process.strategies import *
-from datetime import datetime
-
-
-class Translator:
-    """
-    Turn a bytecode object back into a textual query (Gremlin Groovy script).
-    """
-
-    # 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'                           
-    }
-
-    def __init__(self, traversal_source=None):
-        self.traversal_source = traversal_source
-
-    def get_traversal_source(self):
-        return self.traversal_source
-
-    def get_target_language(self):
-        return "gremlin-groovy"
-
-    def of(self,traversal_source):
-        self.traversal_source = traversal_source
-        return self
-
-    # Do any needed special processing for the representation
-    # of strings and dates.
-    def fixup(self, v):
-        if isinstance(v, str):
-            return f'\'{v}\''
-        elif type(v) == datetime:
-            return self.process_date(v)
-        else:
-            return str(v)
-    
-    # Turn a Python datetime into the equivalent new Date(...)
-    def process_date(self, date):
-        y = date.year - 1900
-        mo = date.month
-        d = date.day
-        h = date.hour
-        mi = date.minute
-        s = date.second
-        return f'new Date({y},{mo},{d},{h},{mi},{s})'
-
-    # 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] + '('
-
-        if type(p.value) == list:
-            res += '['
-            for v in p.value:
-                res += self.fixup(v) + ','
-            res = res[0:-1] + ']'
-        else:
-            res += self.fixup(p.value)
-            if p.other is not None:
-                res+= ',' + 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)
-            else:
-                res += self.fixup(val)
-            c += 1
-        res += ')'
-        return res
-        pass
-
-    # Main driver of the translation. Different parts of
-    # a Traversal are handled appropriately.
-    def do_translation(self, step):
-        script = ''
-        params = step[1:]
-        script += '.' + step[0] + '('
-        if len(params) > 0:
-            c = 0
-            with_opts = False
-            for p in params:
-                script += ',' if c > 0 else ''
-                if with_opts:
-                  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]:
-                    tmp = str(p)
-                    script += tmp[0:-1] if tmp.endswith('_') else tmp 
-                elif type(p) in [ReadOnlyStrategy, SubgraphStrategy, VertexProgramStrategy,
-                                 OptionsStrategy, PartitionStrategy]:
-                    script += self.process_strategy(p)
-                elif type(p) == datetime:
-                    script += self.process_date(p)
-                elif p == WithOptions.tokens:
-                    script += 'WithOptions.tokens'
-                    with_opts = True
-                elif isinstance(p, str):
-                    script += f'\'{p}\''
-                elif type(p) == bool:
-                    script += 'true' if p else 'false'
-                elif p is None:
-                    script += 'null'
-                else:
-                    script += str(p)
-                c += 1
-        script += ')'
-        return script
-
-    # Translation starts here. There are two main parts to a 
-    # traversal. Source instructions such as "withSideEffect"
-    # and "withStrategies", and step instructions such as 
-    # "addV" and "repeat". If child is True we will generate
-    # 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