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

gremlin_python/driver/client.py

@@ -21,7 +21,7 @@ import warnings
 import queue
 from concurrent.futures import ThreadPoolExecutor
 
-from gremlin_python.driver import connection, protocol, request, serializer
+from gremlin_python.driver import connection, request, serializer
 
 log = logging.getLogger("gremlinpython")
 
@@ -36,59 +36,43 @@ except ImportError:
 __author__ = 'David M. Brown (davebshow@gmail.com), Lyndon Bauto (lyndonb@bitquilltech.com)'
 
 
-# TODO: remove session, update connection pooling, etc.
 class Client:
 
-    def __init__(self, url, traversal_source, protocol_factory=None,
-                 transport_factory=None, pool_size=None, max_workers=None,
-                 request_serializer=serializer.GraphBinarySerializersV4(),
+    def __init__(self, url, traversal_source, max_connections=128, max_workers=None,
                  response_serializer=None, interceptors=None, auth=None,
-                 headers=None, enable_user_agent_on_connect=True,
-                 bulk_results=False, **transport_kwargs):
+                 enable_user_agent_on_connect=True,
+                 bulk_results=False, pdt_registry=None, batch_size=None,
+                 **transport_kwargs):
         log.info("Creating Client with url '%s'", url)
 
         self._closed = False
         self._url = url
-        self._headers = headers
+        # A raw list is safe here because Python's GIL ensures list.append and
+        # list.remove are atomic at the bytecode level.
+        self._tracked_transactions = []
         self._enable_user_agent_on_connect = enable_user_agent_on_connect
         self._bulk_results = bulk_results
         self._traversal_source = traversal_source
-        if "max_content_length" not in transport_kwargs:
-            transport_kwargs["max_content_length"] = 10 * 1024 * 1024
+        if batch_size is None:
+            batch_size = 64
+        self._batch_size = batch_size
         if response_serializer is None:
             response_serializer = serializer.GraphBinarySerializersV4()
+        if pdt_registry is not None:
+            response_serializer.configure_pdt_registry(pdt_registry)
 
         self._auth = auth
         self._response_serializer = response_serializer
+        self._interceptors = interceptors
 
-        if transport_factory is None:
-            try:
-                from gremlin_python.driver.aiohttp.transport import AiohttpHTTPTransport
-            except ImportError:
-                raise Exception("Please install AIOHTTP or pass "
-                                "custom transport factory")
-            else:
-                def transport_factory():
-                    if self._protocol_factory is None:
-                        self._protocol_factory = protocol_factory
-                    return AiohttpHTTPTransport(**transport_kwargs)
-        self._transport_factory = transport_factory
-
-        if protocol_factory is None:
-            def protocol_factory():
-                return protocol.GremlinServerHTTPProtocol(
-                    request_serializer, response_serializer, auth=self._auth,
-                    interceptors=interceptors)
-        self._protocol_factory = protocol_factory
-
-        if pool_size is None:
-            pool_size = 8
-        self._pool_size = pool_size
+        self._transport_kwargs = transport_kwargs
+
+        self._max_connections = max_connections
         # This is until concurrent.futures backport 3.1.0 release
         if max_workers is None:
             # If your application is overlapping Gremlin I/O on multiple threads
             # consider passing kwarg max_workers = (cpu_count() or 1) * 5
-            max_workers = pool_size
+            max_workers = max_connections
         self._executor = ThreadPoolExecutor(max_workers=max_workers)
         # Threadsafe queue
         self._pool = queue.Queue()
@@ -110,7 +94,7 @@ class Client:
         return self._traversal_source
 
     def _fill_pool(self):
-        for i in range(self._pool_size):
+        for i in range(self._max_connections):
             conn = self._get_connection()
             self._pool.put_nowait(conn)
 
@@ -123,6 +107,15 @@ class Client:
         if self._closed:
             return
 
+        # Best-effort rollback of any open transactions before closing connections
+        txs = list(self._tracked_transactions)
+        for tx in txs:
+            try:
+                tx.close()
+            except Exception:
+                pass
+        self._tracked_transactions.clear()
+
         log.info("Closing Client with url '%s'", self._url)
         while not self._pool.empty():
             conn = self._pool.get(True)
@@ -130,52 +123,87 @@ class Client:
         self._executor.shutdown()
         self._closed = True
 
-    def _get_connection(self):
-        protocol = self._protocol_factory()
-        return connection.Connection(
-            self._url, self._traversal_source, protocol,
-            self._transport_factory, self._executor, self._pool,
-            headers=self._headers, enable_user_agent_on_connect=self._enable_user_agent_on_connect)
+    def track_transaction(self, tx):
+        self._tracked_transactions.append(tx)
+
+    def untrack_transaction(self, tx):
+        try:
+            self._tracked_transactions.remove(tx)
+        except ValueError:
+            pass
+
+    def transact(self):
+        """Creates a new Transaction for executing operations within an explicit transaction.
 
-    def submit(self, message, bindings=None, request_options=None):
-        return self.submit_async(message, bindings=bindings, request_options=request_options).result()
+        Transactions are short-lived and single-use. After commit or rollback,
+        create a new Transaction for the next unit of work. The traversal source
+        (g alias) is inherited from this Client.
+        """
+        from gremlin_python.driver.transaction import Transaction
+        return Transaction(self)
 
-    def submitAsync(self, message, bindings=None, request_options=None):
+    def _get_connection(self):
+        return connection.Connection(
+            self._url, self._traversal_source,
+            self._executor, self._pool,
+            response_serializer=self._response_serializer,
+            auth=self._auth, interceptors=self._interceptors,
+            enable_user_agent_on_connect=self._enable_user_agent_on_connect,
+            bulk_results=self._bulk_results,
+            max_connections=self._max_connections,
+            **self._transport_kwargs)
+
+    def submit(self, message, parameters=None, request_options=None):
+        return self.submit_async(message, parameters=parameters, request_options=request_options).result()
+
+    def submitAsync(self, message, parameters=None, request_options=None):
         warnings.warn(
             "gremlin_python.driver.client.Client.submitAsync will be replaced by "
             "gremlin_python.driver.client.Client.submit_async.",
             DeprecationWarning)
-        return self.submit_async(message, bindings, request_options)
+        return self.submit_async(message, parameters, request_options)
 
-    def submit_async(self, message, bindings=None, request_options=None):
+    def submit_async(self, message, parameters=None, request_options=None):
         if self.is_closed():
             raise Exception("Client is closed")
 
         log.debug("message '%s'", str(message))
         fields = {'g': self._traversal_source}
 
-        # TODO: bindings is now part of request_options, evaluate the need to keep it separate in python.
-        #  Note this bindings parameter only applies to string script submissions
-        if isinstance(message, str) and bindings:
-            fields['bindings'] = bindings
+        # Note this parameters argument only applies to string script submissions
+        if isinstance(message, str) and parameters:
+            from gremlin_python.process.traversal import GremlinLang
+            if isinstance(parameters, dict):
+                fields['parameters'] = GremlinLang.convert_parameters_to_string(parameters)
+            else:
+                fields['parameters'] = parameters
 
         if isinstance(message, str):
             log.debug("fields='%s', gremlin='%s'", str(fields), str(message))
             message = request.RequestMessage(fields=fields, gremlin=message)
+        else:
+            # A caller-supplied RequestMessage must not be mutated in place:
+            # resubmitting the same message (e.g. on retry) would otherwise
+            # accumulate request_options/batchSize from prior submits. Clone the
+            # fields dict so this submit's mutations stay local, matching the
+            # no-mutate contract of the .NET/JS drivers. Freshly built messages
+            # (the string path above) already own a private fields dict.
+            message = message._replace(fields=dict(message.fields))
 
         conn = self._pool.get(True)
         if request_options:
             message.fields.update({token: request_options[token] for token in request.Tokens
-                                   if token in request_options and token != 'bindings'})
-            if 'bindings' in request_options:
-                if 'bindings' in message.fields:
-                    message.fields['bindings'].update(request_options['bindings'])
-                else:
-                    message.fields['bindings'] = request_options['bindings']
-            if 'params' in request_options:
-                if 'bindings' in message.fields:
-                    message.fields['bindings'].update(request_options['params'])
-                else:
-                    message.fields['bindings'] = request_options['params']
+                                   if token in request_options and token != 'parameters'})
+            if 'parameters' in request_options:
+                parameters_val = request_options['parameters']
+                if isinstance(parameters_val, dict):
+                    from gremlin_python.process.traversal import GremlinLang
+                    parameters_val = GremlinLang.convert_parameters_to_string(parameters_val)
+                message.fields['parameters'] = parameters_val
+
+        # Fill in the connection-level default batch size when the caller did
+        # not set a per-request batchSize.
+        if self._batch_size is not None and 'batchSize' not in message.fields:
+            message.fields['batchSize'] = self._batch_size
 
         return conn.write(message)

gremlin_python/driver/connection.py

@@ -14,29 +14,76 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
+import asyncio
 import queue
 from concurrent.futures import Future
 
+from aiohttp.client_exceptions import (
+    ClientOSError,
+    ClientPayloadError,
+    ServerDisconnectedError,
+)
+
 from gremlin_python.driver import resultset, useragent
+from gremlin_python.driver.aiohttp.transport import AiohttpHTTPTransport
+from gremlin_python.driver.http_request import HttpRequest
 
 __author__ = 'David M. Brown (davebshow@gmail.com)'
 
+_TRANSPORT_ERRORS = (ClientOSError, ClientPayloadError, ServerDisconnectedError, asyncio.IncompleteReadError)
+_CONNECTION_ERROR_MSG = (
+    "Connection to server closed unexpectedly. "
+    "Ensure that the server is still reachable and the connection has not been closed by the server or a network device."
+)
+
+
+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 GremlinConnectionError(Exception):
+    """Raised when a transport-level failure occurs communicating with the server."""
+    pass
+
 
 class Connection:
 
-    def __init__(self, url, traversal_source, protocol, transport_factory,
-                 executor, pool, headers=None, enable_user_agent_on_connect=True,
-                 bulk_results=False):
+    def __init__(self, url, traversal_source,
+                 executor, pool,
+                 response_serializer=None, auth=None, interceptors=None,
+                 enable_user_agent_on_connect=True,
+                 bulk_results=False, **transport_kwargs):
+        if callable(interceptors):
+            interceptors = [interceptors]
+        elif isinstance(interceptors, tuple):
+            interceptors = list(interceptors)
+        elif not (isinstance(interceptors, list) or interceptors is None):
+            raise TypeError("interceptors must be a callable, tuple, list or None")
+
+        # Auth is just an interceptor. As a convenience (and for discoverability), the auth
+        # interceptor is appended to the end of the interceptor list so it runs last, after
+        # any user interceptors have modified the request.
+        if auth is not None:
+            interceptors = (interceptors or []) + [auth]
+
         self._url = url
-        self._headers = headers
+        # Custom request headers are set via interceptors. This internal dict
+        # only carries connection-level headers managed by the driver itself
+        # (user agent, bulkResults) and is established at construction time.
+        self._headers = None
         self._traversal_source = traversal_source
-        self._protocol = protocol
-        self._transport_factory = transport_factory
+        self._transport_kwargs = transport_kwargs
         self._executor = executor
         self._transport = None
         self._pool = pool
         self._result_set = None
         self._inited = False
+        self._response_serializer = response_serializer
+        self._interceptors = interceptors
         self._enable_user_agent_on_connect = enable_user_agent_on_connect
         if self._enable_user_agent_on_connect:
             self.__add_header(useragent.userAgentHeader, useragent.userAgent)
@@ -47,15 +94,45 @@ class Connection:
     def connect(self):
         if self._transport:
             self._transport.close()
-        self._transport = self._transport_factory()
+        self._transport = AiohttpHTTPTransport(**self._transport_kwargs)
         self._transport.connect(self._url, self._headers)
-        self._protocol.connection_made(self._transport)
         self._inited = True
 
     def close(self):
         if self._inited:
             self._transport.close()
 
+    def _write_request(self, request_message):
+        accept = str(self._response_serializer.version, encoding='utf-8')
+
+        headers = {'accept': accept}
+
+        # Promote transactionId to HTTP header before interceptors run.
+        # The field remains in the serialized body as well (dual transmission
+        # per the HTTP transaction protocol specification).
+        if hasattr(request_message, 'fields') and 'transactionId' in request_message.fields:
+            headers['X-Transaction-Id'] = request_message.fields['transactionId']
+
+        http_request = HttpRequest(
+            method="POST",
+            url=self._url,
+            headers=headers,
+            body=request_message
+        )
+
+        for interceptor in self._interceptors or []:
+            interceptor(http_request)
+
+        # Auto-serialize if no interceptor already did so
+        http_request.serialize_body()
+
+        # Build the transport message in the format the transport expects
+        message = {
+            'headers': http_request.headers,
+            'payload': http_request.body
+        }
+        self._transport.write(message)
+
     def write(self, request_message):
         if not self._inited:
             self.connect()
@@ -63,11 +140,16 @@ class Connection:
         # Create write task
         future = Future()
         future_write = self._executor.submit(
-            self._protocol.write, request_message)
+            self._write_request, request_message)
 
         def cb(f):
             try:
                 f.result()
+            except _TRANSPORT_ERRORS as e:
+                wrapped = GremlinConnectionError(_CONNECTION_ERROR_MSG)
+                wrapped.__cause__ = e
+                future.set_exception(wrapped)
+                self._pool.put_nowait(self)
             except Exception as e:
                 future.set_exception(e)
                 self._pool.put_nowait(self)
@@ -82,19 +164,41 @@ class Connection:
 
     def _receive(self):
         try:
-            '''
-            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.
-            '''
-            self._protocol.data_received_aggregate(self._transport.read(), self._result_set)
-            # re-enable streaming after graphSON removal
-            # self._transport.read(self.stream_chunk)
+            # Surface error responses whose Content-Type doesn't match the
+            # configured response serializer (e.g. plain-text 5xx).
+            status = getattr(self._transport, 'status_code', None)
+            response_content_type = str(self._response_serializer.version, encoding='utf-8')
+            if status is not None and status >= 400:
+                content_type = getattr(self._transport, 'content_type', '')
+                if response_content_type not in content_type:
+                    body = self._transport.read_body().decode('utf-8', errors='replace')
+                    raise GremlinServerError({
+                        'code': status,
+                        'message': body,
+                        'exception': ''
+                    })
+
+            # 204 No Content
+            if status == 204:
+                return
+
+            # Stream items through the configured response serializer; it
+            # raises GremlinServerError if the response ends with a non-success status.
+            stream = self._transport.get_stream()
+            for obj in self._response_serializer.deserialize_response_stream(stream):
+                self._result_set.stream.put_nowait(obj)
+        except _TRANSPORT_ERRORS as err:
+            # Evict the dead connection from aiohttp's internal pool, ensuring subsequent
+            # requests get a fresh connection.
+            self._transport.evict_response()
+            msg = 'Server returned an empty response body' if isinstance(err, asyncio.IncompleteReadError) and not err.partial else _CONNECTION_ERROR_MSG
+            raise GremlinConnectionError(msg) from err
+        except Exception:
+            self._transport.evict_response()
+            raise
         finally:
             self._pool.put_nowait(self)
 
-    def stream_chunk(self, chunk_data, read_completed=None, http_req_resp=None):
-        self._protocol.data_received(chunk_data, self._result_set, read_completed, http_req_resp)
-
     def __add_header(self, key, value):
         if self._headers is None:
             self._headers = dict()

gremlin_python/driver/driver_remote_connection.py

@@ -18,7 +18,6 @@
 #
 import logging
 from concurrent.futures import Future
-import warnings
 
 from gremlin_python.driver import client, serializer
 from gremlin_python.driver.remote_connection import RemoteConnection, RemoteTraversal
@@ -31,38 +30,34 @@ __author__ = 'David M. Brown (davebshow@gmail.com), Lyndon Bauto (lyndonb@bitqui
 
 class DriverRemoteConnection(RemoteConnection):
 
-    def __init__(self, url, traversal_source="g", protocol_factory=None,
-                 transport_factory=None, pool_size=None, max_workers=None,
-                 request_serializer=serializer.GraphBinarySerializersV4(),
+    def __init__(self, url, traversal_source="g",
+                 max_connections=128, max_workers=None,
                  response_serializer=None, interceptors=None, auth=None,
-                 headers=None, enable_user_agent_on_connect=True,
-                 bulk_results=False, **transport_kwargs):
+                 enable_user_agent_on_connect=True,
+                 bulk_results=False, pdt_registry=None, batch_size=None,
+                 **transport_kwargs):
         log.info("Creating DriverRemoteConnection with url '%s'", str(url))
         self.__url = url
         self.__traversal_source = traversal_source
-        self.__protocol_factory = protocol_factory
-        self.__transport_factory = transport_factory
-        self.__pool_size = pool_size
+        self.__max_connections = max_connections
         self.__max_workers = max_workers
         self.__auth = auth
-        self.__headers = headers
         self.__enable_user_agent_on_connect = enable_user_agent_on_connect
         self.__bulk_results = bulk_results
         self.__transport_kwargs = transport_kwargs
+        self.pdt_registry = pdt_registry
 
         if response_serializer is None:
             response_serializer = serializer.GraphBinarySerializersV4()
         self._client = client.Client(url, traversal_source,
-                                     protocol_factory=protocol_factory,
-                                     transport_factory=transport_factory,
-                                     pool_size=pool_size,
+                                     max_connections=max_connections,
                                      max_workers=max_workers,
-                                     request_serializer=request_serializer,
                                      response_serializer=response_serializer,
                                      interceptors=interceptors, auth=auth,
-                                     headers=headers,
                                      enable_user_agent_on_connect=enable_user_agent_on_connect,
                                      bulk_results=bulk_results,
+                                     pdt_registry=pdt_registry,
+                                     batch_size=batch_size,
                                      **transport_kwargs)
         self._url = self._client._url
         self._traversal_source = self._client._traversal_source
@@ -74,31 +69,20 @@ class DriverRemoteConnection(RemoteConnection):
 
     def submit(self, gremlin_lang):
         log.debug("submit with gremlin lang script '%s'", gremlin_lang.get_gremlin())
-        gremlin_lang.add_g(self._traversal_source)
         result_set = self._client.submit(gremlin_lang.get_gremlin(),
                                          request_options=self.extract_request_options(gremlin_lang))
-        results = result_set.all().result()
-        return RemoteTraversal(iter(results))
-
-    def submitAsync(self, message, bindings=None, request_options=None):
-        warnings.warn(
-            "gremlin_python.driver.driver_remote_connection.DriverRemoteConnection.submitAsync will be replaced by "
-            "gremlin_python.driver.driver_remote_connection.DriverRemoteConnection.submit_async.",
-            DeprecationWarning)
-        self.submit_async(message, bindings, request_options)
+        return RemoteTraversal(result_set)
 
     def submit_async(self, gremlin_lang):
         log.debug("submit_async with gremlin lang script '%s'", gremlin_lang.get_gremlin())
         future = Future()
-        gremlin_lang.add_g(self._traversal_source)
         future_result_set = self._client.submit_async(gremlin_lang.get_gremlin(),
                                                       request_options=self.extract_request_options(gremlin_lang))
 
         def cb(f):
             try:
                 result_set = f.result()
-                results = result_set.all().result()
-                future.set_result(RemoteTraversal(iter(results)))
+                future.set_result(RemoteTraversal(result_set))
             except Exception as e:
                 future.set_exception(e)
 
@@ -108,15 +92,6 @@ class DriverRemoteConnection(RemoteConnection):
     def is_closed(self):
         return self._client.is_closed()
 
-    # TODO remove or update once HTTP transaction is implemented
-    # def commit(self):
-    #     log.info("Submitting commit graph operation.")
-    #     return self._client.submit(Bytecode.GraphOp.commit())
-    #
-    # def rollback(self):
-    #     log.info("Submitting rollback graph operation.")
-    #     return self._client.submit(Bytecode.GraphOp.rollback())
-
     @staticmethod
     def extract_request_options(gremlin_lang):
         request_options = {}
@@ -126,7 +101,9 @@ class DriverRemoteConnection(RemoteConnection):
         # request the server to bulk results by default when using drc through request options
         if 'bulkResults' not in request_options:
             request_options['bulkResults'] = True
-        if gremlin_lang.parameters is not None and len(gremlin_lang.parameters) > 0:
-            request_options["params"] = gremlin_lang.parameters
+
+        parameters_string = gremlin_lang.get_parameters_as_string()
+        if parameters_string != '[:]':
+            request_options["parameters"] = parameters_string
 
         return request_options

gremlin_python/driver/{transport.py → exceptions.py}

@@ -16,30 +16,16 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-import abc
 
-__author__ = 'David M. Brown (davebshow@gmail.com)'
+class ReadTimeoutError(TimeoutError):
+    """Raised when the client-side read timeout elapses while waiting for response
+    data from the server.
 
+    Subclasses the builtin :class:`TimeoutError` so it can be caught with
+    ``except TimeoutError`` without depending on the underlying transport.
 
-class AbstractBaseTransport(metaclass=abc.ABCMeta):
-
-    @abc.abstractmethod
-    def connect(self, url, headers=None):
-        pass
-
-    @abc.abstractmethod
-    def write(self, message):
-        pass
-
-    @abc.abstractmethod
-    def read(self):
-        pass
-
-    @abc.abstractmethod
-    def close(self):
-        pass
-
-    @property
-    @abc.abstractmethod
-    def closed(self):
-        pass
+    This driver-owned type exists only because the driver is currently synchronous and
+    should not surface the transport's asyncio/aiohttp timeout types. Once gremlin-python
+    is fully asynchronous this should be reverted to raising ``asyncio.TimeoutError``
+    directly. See TINKERPOP-2774: https://issues.apache.org/jira/browse/TINKERPOP-2774
+    """

gremlin_python/driver/http_request.py

@@ -0,0 +1,65 @@
+#
+# 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 json
+
+from gremlin_python.driver.request import RequestMessage
+
+
+class HttpRequest:
+    """Represents the HTTP request passed through the interceptor chain.
+
+    The body starts as a RequestMessage and can be serialized to JSON bytes
+    via serialize_body(). Interceptors mutate this object in place.
+    """
+
+    def __init__(self, method, url, headers, body):
+        self.method = method
+        self.url = url
+        self.headers = headers
+        self.body = body
+
+    def serialize_body(self):
+        """Serialize the body to JSON bytes if it is still a RequestMessage.
+
+        If the body is already bytes, returns them as-is (idempotent).
+        Sets the Content-Type header to application/json and Content-Length
+        to the byte length of the serialized body.
+
+        Returns:
+            bytes: the serialized body
+
+        Raises:
+            TypeError: if the body is neither a RequestMessage nor bytes
+        """
+        if isinstance(self.body, bytes):
+            return self.body
+
+        if not isinstance(self.body, RequestMessage):
+            raise TypeError(
+                f"Cannot serialize body of type {type(self.body).__name__}. "
+                "Expected RequestMessage or bytes."
+            )
+
+        payload = {"gremlin": self.body.gremlin}
+        payload.update(self.body.fields)
+        data = json.dumps(payload).encode("utf-8")
+        self.body = data
+        self.headers["content-type"] = "application/json"
+        self.headers["content-length"] = str(len(data))
+        return data

gremlin_python/driver/request.py

@@ -23,5 +23,6 @@ __author__ = 'David M. Brown (davebshow@gmail.com)'
 RequestMessage = collections.namedtuple(
     'RequestMessage', ['fields', 'gremlin'])
 
-Tokens = ['batchSize', 'bindings', 'g', 'gremlin', 'language',
-          'evaluationTimeout', 'materializeProperties', 'timeoutMs', 'userAgent', 'bulkResults']
+Tokens = ['batchSize', 'parameters', 'g', 'gremlin', 'language',
+          'materializeProperties', 'timeoutMillis', 'userAgent', 'bulkResults',
+          'transactionId']