gremlinpython 3.7.4__tar.gz → 4.0.0b1__tar.gz

gremlinpython-4.0.0b1/NOTICE

@@ -0,0 +1,5 @@
+Apache TinkerPop
+Copyright 2015-2024 The Apache Software Foundation.
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).

{gremlinpython-3.7.4/gremlinpython.egg-info → gremlinpython-4.0.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gremlinpython
-Version: 3.7.4
+Version: 4.0.0b1
 Summary: Gremlin-Python for Apache TinkerPop
 Home-page: https://tinkerpop.apache.org
 Maintainer: Apache TinkerPop

{gremlinpython-3.7.4 → gremlinpython-4.0.0b1}/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.7.4'
-timestamp = 1754672102
+version   = '4.0.0-beta.1'
+timestamp = 1737668264

gremlinpython-4.0.0b1/gremlin_python/driver/aiohttp/transport.py

@@ -0,0 +1,182 @@
+#
+# 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
+
+import aiohttp
+import asyncio
+import sys
+
+if sys.version_info >= (3, 11):
+    import asyncio as async_timeout
+else:
+    import async_timeout
+from aiohttp import ClientPayloadError
+from gremlin_python.driver.protocol import GremlinServerError
+from gremlin_python.driver.transport import AbstractBaseTransport
+
+__author__ = 'Lyndon Bauto (lyndonb@bitquilltech.com)'
+
+
+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 AiohttpHTTPTransport.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()
+            AiohttpHTTPTransport.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
+        self._url = None
+
+        # Set all inner variables to parameters passed in.
+        self._aiohttp_kwargs = kwargs
+        self._write_timeout = write_timeout
+        self._read_timeout = read_timeout
+        if "max_content_length" in self._aiohttp_kwargs:
+            self._max_content_len = self._aiohttp_kwargs.pop("max_content_length")
+        else:
+            self._max_content_len = 10 * 1024 * 1024
+        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):
+        self._url = url
+        # Inner function to perform async connect.
+        async def async_connect():
+            # Start client session and use it to send all HTTP requests. Headers can be set here.
+            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,
+                                                             headers=headers, loop=self._loop)
+            else:
+                self._client_session = aiohttp.ClientSession(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():
+            # To pass url into message for request authentication processing
+            message.update({'url': self._url})
+            if message['auth']:
+                message['auth'](message)
+
+            async with async_timeout.timeout(self._write_timeout):
+                self._http_req_resp = await self._client_session.post(url=self._url,
+                                                                      data=message['payload'],
+                                                                      headers=message['headers'],
+                                                                      **self._aiohttp_kwargs)
+
+        # Execute the async write synchronously.
+        self._loop.run_until_complete(async_write())
+
+    def read(self, stream_chunk=None):
+        if not stream_chunk:
+            '''
+            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.
+            '''
+            async def async_read():
+                async with async_timeout.timeout(self._read_timeout):
+                    data_buffer = b""
+                    async for data, end_of_http_chunk in self._http_req_resp.content.iter_chunks():
+                        try:
+                            data_buffer += data
+                        except ClientPayloadError:
+                            # server disconnect during streaming will cause ClientPayLoadError from aiohttp
+                            raise GremlinServerError({'code': 500,
+                                                      'message': 'Server disconnected - please try to reconnect',
+                                                      'exception': ClientPayloadError})
+                    if self._max_content_len and len(
+                            data_buffer) > self._max_content_len:
+                        raise Exception(f'Response size {len(data_buffer)} exceeds limit {self._max_content_len} bytes')
+                    if self._http_req_resp.headers.get('content-type') == 'application/json':
+                        message = json.loads(data_buffer.decode('utf-8'))
+                        err = message.get('message')
+                        raise Exception(f'Server disconnected with error message: "{err}" - please try to reconnect')
+                    return data_buffer
+            return self._loop.run_until_complete(async_read())
+            # raise Exception('missing handling of streamed responses to protocol')
+
+        # Inner function to perform async read.
+        async def async_read():
+            # TODO: potentially refactor to just use streaming and remove transport/protocol
+            async with async_timeout.timeout(self._read_timeout):
+                read_completed = False
+                # aiohttp streaming may not iterate through one whole chunk if it's too large, need to buffer it
+                data_buffer = b""
+                async for data, end_of_http_chunk in self._http_req_resp.content.iter_chunks():
+                    try:
+                        data_buffer += data
+                        if end_of_http_chunk:
+                            if self._max_content_len and len(
+                                    data_buffer) > self._max_content_len:
+                                raise Exception(  # TODO: do we need proper exception class for this?
+                                    f'Response size {len(data_buffer)} exceeds limit {self._max_content_len} bytes')
+                            stream_chunk(data_buffer, read_completed, self._http_req_resp.ok)
+                            data_buffer = b""
+                    except ClientPayloadError:
+                        # server disconnect during streaming will cause ClientPayLoadError from aiohttp
+                        # TODO: double check during refactoring
+                        raise GremlinServerError({'code': 500,
+                                                  'message': 'Server disconnected - please try to reconnect',
+                                                  'exception': ClientPayloadError})
+                read_completed = True
+                stream_chunk(data_buffer, read_completed, self._http_req_resp.ok)
+
+        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-4.0.0b1/gremlin_python/driver/auth.py

@@ -0,0 +1,55 @@
+#
+# 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.
+#
+
+
+def basic(username, password):
+    from aiohttp import BasicAuth as aiohttpBasicAuth
+
+    def apply(request):
+        return request['headers'].update({'authorization': aiohttpBasicAuth(username, password).encode()})
+
+    return apply
+
+
+def sigv4(region, service):
+    import os
+    from boto3 import Session
+    from botocore.auth import SigV4Auth
+    from botocore.awsrequest import AWSRequest
+
+    def apply(request):
+        access_key = os.environ.get('AWS_ACCESS_KEY_ID', '')
+        secret_key = os.environ.get('AWS_SECRET_ACCESS_KEY', '')
+        session_token = os.environ.get('AWS_SESSION_TOKEN', '')
+
+        session = Session(
+            aws_access_key_id=access_key,
+            aws_secret_access_key=secret_key,
+            aws_session_token=session_token,
+            region_name=region
+        )
+
+        sigv4_request = AWSRequest(method="POST", url=request['url'], data=request['payload'])
+        SigV4Auth(session.get_credentials(), service, region).add_auth(sigv4_request)
+        request['headers'].update(sigv4_request.headers)
+        request['payload'] = sigv4_request.data
+        return request
+
+    return apply
+

{gremlinpython-3.7.4 → gremlinpython-4.0.0b1}/gremlin_python/driver/client.py

@@ -19,11 +19,9 @@
 import logging
 import warnings
 import queue
-import re
 from concurrent.futures import ThreadPoolExecutor
 
 from gremlin_python.driver import connection, protocol, request, serializer
-from gremlin_python.process import traversal
 
 log = logging.getLogger("gremlinpython")
 
@@ -38,69 +36,51 @@ 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,
-                 message_serializer=None, username="", password="",
-                 kerberized_service="", headers=None, session=None,
-                 enable_user_agent_on_connect=True, enable_compression=False,
-                 **transport_kwargs):
+                 request_serializer=serializer.GraphBinarySerializersV4(),
+                 response_serializer=None, interceptors=None, auth=None,
+                 headers=None, enable_user_agent_on_connect=True,
+                 bulk_results=False, **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._bulk_results = bulk_results
         self._traversal_source = traversal_source
-        self._enable_compression = enable_compression
-        if not self._use_http and "max_content_length" not in transport_kwargs:
+        if "max_content_length" not in transport_kwargs:
             transport_kwargs["max_content_length"] = 10 * 1024 * 1024
-        if message_serializer is None:
-            message_serializer = serializer.GraphBinarySerializersV1()
-
-        self._message_serializer = message_serializer
-        self._username = username
-        self._password = password
-        self._session = session
-        self._session_enabled = (session is not None and session != "")
+        if response_serializer is None:
+            response_serializer = serializer.GraphBinarySerializersV4()
+
+        self._auth = auth
+        self._response_serializer = response_serializer
+
         if transport_factory is None:
             try:
-                from gremlin_python.driver.aiohttp.transport import (
-                    AiohttpTransport, AiohttpHTTPTransport)
+                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._use_http:
-                        return AiohttpHTTPTransport(**transport_kwargs)
-                    else:
-                        return AiohttpTransport(enable_compression=enable_compression, **transport_kwargs)
+                    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():
-                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"])
+                return protocol.GremlinServerHTTPProtocol(
+                    request_serializer, response_serializer, auth=self._auth,
+                    interceptors=interceptors)
         self._protocol_factory = protocol_factory
-        if self._session_enabled:
-            if pool_size is None:
-                pool_size = 1
-            elif pool_size != 1:
-                raise Exception("PoolSize must be 1 on session mode!")
+
         if pool_size is None:
             pool_size = 8
         self._pool_size = pool_size
@@ -117,6 +97,9 @@ class Client:
     @property
     def available_pool_size(self):
         return self._pool.qsize()
+    
+    def response_serializer(self):
+        return self._response_serializer
 
     @property
     def executor(self):
@@ -140,8 +123,6 @@ class Client:
         if self._closed:
             return
 
-        if self._session_enabled:
-            self._close_session()
         log.info("Closing Client with url '%s'", self._url)
         while not self._pool.empty():
             conn = self._pool.get(True)
@@ -149,17 +130,6 @@ class Client:
         self._executor.shutdown()
         self._closed = True
 
-    def _close_session(self):
-        message = request.RequestMessage(
-            processor='session', op='close',
-            args={'session': str(self._session)})
-        conn = self._pool.get(True)
-        try:
-            write_result_set = conn.write(message).result()
-            return write_result_set.all().result()  # wait for _receive() to finish
-        except protocol.GremlinServerError:
-            pass
-
     def _get_connection(self):
         protocol = self._protocol_factory()
         return connection.Connection(
@@ -182,25 +152,30 @@ class Client:
             raise Exception("Client is closed")
 
         log.debug("message '%s'", str(message))
-        args = {'gremlin': message, 'aliases': {'g': self._traversal_source}}
-        processor = ''
-        op = 'eval'
-        if isinstance(message, traversal.Bytecode):
-            op = 'bytecode'
-            processor = 'traversal'
+        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:
-            args['bindings'] = bindings
-
-        if self._session_enabled:
-            args['session'] = str(self._session)
-            processor = 'session'
+            fields['bindings'] = bindings
 
-        if isinstance(message, traversal.Bytecode) or isinstance(message, str):
-            log.debug("processor='%s', op='%s', args='%s'", str(processor), str(op), str(args))
-            message = request.RequestMessage(processor=processor, op=op, args=args)
+        if isinstance(message, str):
+            log.debug("fields='%s', gremlin='%s'", str(fields), str(message))
+            message = request.RequestMessage(fields=fields, gremlin=message)
 
         conn = self._pool.get(True)
         if request_options:
-            message.args.update(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']
+
         return conn.write(message)

{gremlinpython-3.7.4 → gremlinpython-4.0.0b1}/gremlin_python/driver/connection.py

@@ -14,7 +14,6 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-import uuid
 import queue
 from concurrent.futures import Future
 
@@ -26,7 +25,8 @@ __author__ = 'David M. Brown (davebshow@gmail.com)'
 class Connection:
 
     def __init__(self, url, traversal_source, protocol, transport_factory,
-                 executor, pool, headers=None, enable_user_agent_on_connect=True):
+                 executor, pool, headers=None, enable_user_agent_on_connect=True,
+                 bulk_results=False):
         self._url = url
         self._headers = headers
         self._traversal_source = traversal_source
@@ -35,11 +35,14 @@ class Connection:
         self._executor = executor
         self._transport = None
         self._pool = pool
-        self._results = {}
+        self._result_set = None
         self._inited = False
         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)
+        self._bulk_results = bulk_results
+        if self._bulk_results:
+            self.__add_header("bulkResults", "true")
 
     def connect(self):
         if self._transport:
@@ -56,17 +59,11 @@ class Connection:
     def write(self, request_message):
         if not self._inited:
             self.connect()
-        if request_message.args.get("requestId"):
-            request_id = str(request_message.args.get("requestId"))
-            uuid.UUID(request_id)  # Checks for proper UUID or else server will return an error.
-        else:
-            request_id = str(uuid.uuid4())
-        result_set = resultset.ResultSet(queue.Queue(), request_id)
-        self._results[request_id] = result_set
+        self._result_set = resultset.ResultSet(queue.Queue())
         # Create write task
         future = Future()
         future_write = self._executor.submit(
-            self._protocol.write, request_id, request_message)
+            self._protocol.write, request_message)
 
         def cb(f):
             try:
@@ -77,22 +74,27 @@ class Connection:
             else:
                 # Start receive task
                 done = self._executor.submit(self._receive)
-                result_set.done = done
-                future.set_result(result_set)
+                self._result_set.done = done
+                future.set_result(self._result_set)
 
         future_write.add_done_callback(cb)
         return future
 
     def _receive(self):
         try:
-            while True:
-                data = self._transport.read()
-                status_code = self._protocol.data_received(data, self._results)
-                if status_code != 206:
-                    break
+            '''
+            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)
         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()

gremlinpython-4.0.0b1/gremlin_python/driver/driver_remote_connection.py

@@ -0,0 +1,132 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+import logging
+from concurrent.futures import Future
+import warnings
+
+from gremlin_python.driver import client, serializer
+from gremlin_python.driver.remote_connection import RemoteConnection, RemoteTraversal
+from gremlin_python.driver.request import Tokens
+
+log = logging.getLogger("gremlinpython")
+
+__author__ = 'David M. Brown (davebshow@gmail.com), Lyndon Bauto (lyndonb@bitquilltech.com)'
+
+
+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(),
+                 response_serializer=None, interceptors=None, auth=None,
+                 headers=None, enable_user_agent_on_connect=True,
+                 bulk_results=False, **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_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
+
+        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_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,
+                                     **transport_kwargs)
+        self._url = self._client._url
+        self._traversal_source = self._client._traversal_source
+
+    def close(self):
+        log.info("closing DriverRemoteConnection with url '%s'", str(self._url))
+
+        self._client.close()
+
+    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)
+
+    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)))
+            except Exception as e:
+                future.set_exception(e)
+
+        future_result_set.add_done_callback(cb)
+        return future
+
+    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 = {}
+        for os in gremlin_lang.options_strategies:
+            request_options.update({token: os.configuration[token] for token in Tokens
+                                    if token in os.configuration})
+        # 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
+
+        return request_options