gremlinpython 4.0.0b2__tar.gz → 4.0.0.dev1__tar.gz

{gremlinpython-4.0.0b2/gremlinpython.egg-info → gremlinpython-4.0.0.dev1}/PKG-INFO

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

{gremlinpython-4.0.0b2 → gremlinpython-4.0.0.dev1}/gremlin_python/__init__.py

@@ -18,4 +18,4 @@
 #
 
 __author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'
-__version__ = '4.0.0b2'
+__version__ = '4.0.0.dev1'

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

@@ -0,0 +1,354 @@
+#
+# 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 aiohttp
+import asyncio
+import socket
+import sys
+
+from gremlin_python.driver.exceptions import ReadTimeoutError
+
+if sys.version_info >= (3, 11):
+    import asyncio as async_timeout
+else:
+    import async_timeout
+
+__author__ = 'Lyndon Bauto (lyndonb@bitquilltech.com)'
+
+# Default connection option values (canonical TinkerPop 4.x GLV defaults). The millisecond-suffixed
+# options are the primary form (mirroring the other GLVs); aiohttp itself works in seconds, so the
+# values are converted internally.
+DEFAULT_CONNECT_TIMEOUT_MILLIS = 5000
+DEFAULT_IDLE_TIMEOUT_MILLIS = 180000
+DEFAULT_KEEP_ALIVE_TIME_MILLIS = 30000
+# Seconds equivalents retained for internal use / backwards reference.
+DEFAULT_CONNECT_TIMEOUT = DEFAULT_CONNECT_TIMEOUT_MILLIS / 1000
+DEFAULT_IDLE_TIMEOUT = DEFAULT_IDLE_TIMEOUT_MILLIS / 1000
+DEFAULT_KEEP_ALIVE_TIME = DEFAULT_KEEP_ALIVE_TIME_MILLIS / 1000
+DEFAULT_COMPRESSION = 'deflate'
+
+def _resolve_timeout_seconds(millis, seconds, default_millis):
+    """Resolve a timeout to seconds (aiohttp's unit) from the ``*_millis`` number or the idiomatic
+    unsuffixed seconds number (``None`` means not supplied for either). Supplying both raises
+    ``ValueError``; if neither is given, ``default_millis`` is used (``None`` leaves it unset).
+    """
+    if millis is not None and seconds is not None:
+        raise ValueError("provide only one of the milliseconds option or the seconds option, not both")
+    if seconds is not None:
+        return seconds
+    if millis is not None:
+        return millis / 1000
+    if default_millis is None:
+        return None
+    return default_millis / 1000
+
+
+def _normalize_compression(compression):
+    """Normalize the compression option to a canonical string ('none' or 'deflate').
+
+    Accepts the string forms 'none'/'deflate'.
+    """
+    if compression is None:
+        return DEFAULT_COMPRESSION
+    if isinstance(compression, str):
+        normalized = compression.lower()
+        if normalized in ('none', 'deflate'):
+            return normalized
+        raise ValueError("compression must be one of 'none', 'deflate', got '%s'" % compression)
+    raise TypeError("compression must be a str ('none'|'deflate'), got %s" % type(compression).__name__)
+
+
+def _run_read(loop, read_timeout, coro):
+    """Run a response-read coroutine on ``loop``, normalizing aiohttp's read timeout
+    (SocketTimeoutError / ServerTimeoutError) into a ``ReadTimeoutError`` so a read
+    timeout always surfaces as one deterministic, transport-agnostic type. It subclasses
+    the builtin ``TimeoutError`` so callers can still ``except TimeoutError``."""
+    try:
+        return loop.run_until_complete(coro)
+    except aiohttp.ServerTimeoutError as e:
+        raise ReadTimeoutError(
+            f"Read timed out after {read_timeout}s waiting for response data.") from e
+
+
+def _keep_alive_socket_options(keep_alive_time):
+    """Build the list of socket options that enable TCP keep-alive with the
+    given idle time before probes begin. TCP_KEEPIDLE is platform dependent
+    (Linux); macOS exposes the equivalent as TCP_KEEPALIVE. Both are guarded so
+    platforms lacking the option (e.g. Windows) simply enable SO_KEEPALIVE."""
+    options = [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)]
+    idle_opt = getattr(socket, 'TCP_KEEPIDLE', None)
+    if idle_opt is None:
+        # macOS names the idle-before-probe option TCP_KEEPALIVE
+        idle_opt = getattr(socket, 'TCP_KEEPALIVE', None)
+    if idle_opt is not None:
+        options.append((socket.IPPROTO_TCP, idle_opt, int(keep_alive_time)))
+    return options
+
+
+def _keep_alive_socket_factory(keep_alive_time):
+    """Return a socket_factory (aiohttp >= 3.11) that applies the keep-alive
+    socket options when each connection socket is created."""
+    options = _keep_alive_socket_options(keep_alive_time)
+
+    def factory(addr_info):
+        family, type_, proto, _, _ = addr_info
+        sock = socket.socket(family=family, type=type_, proto=proto)
+        for level, optname, value in options:
+            try:
+                sock.setsockopt(level, optname, value)
+            except (OSError, AttributeError):
+                pass
+        return sock
+
+    return factory
+
+
+class AiohttpSyncStream:
+    """Wraps aiohttp's async StreamReader as a synchronous file-like object.
+    read(n) blocks until exactly n bytes are available from the HTTP response.
+
+    Maintains an internal byte buffer that is refilled one HTTP chunk at a time
+    so the deserializer's many small read(n) calls don't each pay the cost of a
+    full asyncio event-loop turn."""
+
+    # Max bytes pulled from the response per underlying read. Matches
+    # aiohttp.StreamReader's default 64 KB limit, which is the per-connection
+    # high-water mark, asking for more in one read() never returns more.
+    _FILL_SIZE = 64 * 1024
+
+    def __init__(self, response, loop, read_timeout):
+        self._response = response
+        self._loop = loop
+        self._read_timeout = read_timeout
+        self._buf = bytearray()
+        self._pos = 0
+
+    def read(self, n):
+        if n <= 0:
+            return b''
+        while len(self._buf) - self._pos < n:
+            data = self._read_chunk()
+            if not data:
+                partial = bytes(self._buf[self._pos:])
+                self._buf.clear()
+                self._pos = 0
+                raise asyncio.IncompleteReadError(partial=partial, expected=n)
+            self._buf.extend(data)
+        end = self._pos + n
+        out = bytes(self._buf[self._pos:end])
+        self._pos = end
+        # Reclaim memory once the buffer is fully drained
+        if self._pos == len(self._buf):
+            self._buf.clear()
+            self._pos = 0
+        return out
+
+    def _read_chunk(self):
+        return _run_read(self._loop, self._read_timeout,
+                         self._response.content.read(self._FILL_SIZE))
+
+
+class AiohttpHTTPTransport:
+    nest_asyncio_applied = False
+
+    def __init__(self, call_from_event_loop=None, write_timeout=None,
+                 connect_timeout_millis=None, connect_timeout=None,
+                 idle_timeout_millis=None, idle_timeout=None,
+                 read_timeout_millis=None, read_timeout=None,
+                 keep_alive_time_millis=None, keep_alive_time=None,
+                 compression=DEFAULT_COMPRESSION, proxy=None, trust_env=False,
+                 max_connections=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._ssl_context = None
+        self._url = None
+
+        # Set all inner variables to parameters passed in.
+        self._aiohttp_kwargs = kwargs
+        self._write_timeout = write_timeout
+
+        # Timeouts accept a millisecond number (*_millis, primary form) or the idiomatic seconds number
+        # (unsuffixed). read_timeout defaults off; the others use the canonical millisecond defaults.
+        self._read_timeout = _resolve_timeout_seconds(read_timeout_millis, read_timeout, None)
+
+        # Connection-level pooling / lifecycle options.
+        self._connect_timeout = _resolve_timeout_seconds(connect_timeout_millis, connect_timeout, DEFAULT_CONNECT_TIMEOUT_MILLIS)
+        self._idle_timeout = _resolve_timeout_seconds(idle_timeout_millis, idle_timeout, DEFAULT_IDLE_TIMEOUT_MILLIS)
+        self._keep_alive_time = _resolve_timeout_seconds(keep_alive_time_millis, keep_alive_time, DEFAULT_KEEP_ALIVE_TIME_MILLIS)
+        # Caps the aiohttp connector's simultaneous connections per Connection
+        # (the Client also sizes its Connection pool by this value).
+        self._max_connections = max_connections
+
+        # Compression negotiation. Default 'deflate' (on); advertises
+        # Accept-Encoding: deflate. Set 'none' to opt out.
+        self._compression = _normalize_compression(compression)
+
+        # HTTP proxy support routed through the ClientSession.
+        self._proxy = proxy
+        self._trust_env = trust_env
+
+        # ssl: canonical name accepting an ssl.SSLContext.
+        if "ssl" in self._aiohttp_kwargs:
+            self._ssl_context = self._aiohttp_kwargs.pop("ssl")
+            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():
+            # Build the TCP connector with the standardized pooling / lifecycle
+            # options. keepalive_timeout maps to the idle connection timeout;
+            # the socket factory enables TCP keep-alive probes after
+            # keep_alive_time idle.
+            connector_kwargs = {}
+            if self._enable_ssl:
+                # ssl context is established through the tcp connector
+                connector_kwargs['ssl_context'] = self._ssl_context
+            if self._idle_timeout is not None:
+                connector_kwargs['keepalive_timeout'] = self._idle_timeout
+            if self._keep_alive_time is not None:
+                self._apply_keep_alive(connector_kwargs)
+            # Reflect max_connections at the aiohttp layer so the connector's
+            # simultaneous-connection limit matches the driver option.
+            if self._max_connections is not None:
+                connector_kwargs['limit'] = self._max_connections
+
+            session_kwargs = {'headers': headers, 'loop': self._loop,
+                              'trust_env': self._trust_env}
+            # Use the per-socket timeouts (sock_connect/sock_read) rather than a
+            # whole-request total, which would abort long but legitimate streaming
+            # responses. sock_read bounds idle time between chunks so a stalled
+            # server cannot hang forever.
+            timeout_kwargs = {}
+            if self._connect_timeout is not None:
+                timeout_kwargs['sock_connect'] = self._connect_timeout
+            if self._read_timeout is not None:
+                timeout_kwargs['sock_read'] = self._read_timeout
+            if timeout_kwargs:
+                session_kwargs['timeout'] = aiohttp.ClientTimeout(**timeout_kwargs)
+            if connector_kwargs:
+                session_kwargs['connector'] = aiohttp.TCPConnector(**connector_kwargs)
+
+            self._client_session = aiohttp.ClientSession(**session_kwargs)
+
+        # Execute the async connect synchronously.
+        self._loop.run_until_complete(async_connect())
+
+    def _apply_keep_alive(self, connector_kwargs):
+        """Wire TCP keep-alive into the connector via the aiohttp socket_factory.
+        The factory sets SO_KEEPALIVE plus the per-socket idle time; unsupported
+        platforms degrade gracefully inside the factory."""
+        connector_kwargs['socket_factory'] = _keep_alive_socket_factory(self._keep_alive_time)
+
+    def write(self, message):
+        # Negotiate compression unless the caller already set Accept-Encoding:
+        # deflate advertises Accept-Encoding: deflate; none suppresses aiohttp's
+        # auto-injected Accept-Encoding so compression is not silently negotiated.
+        headers = message['headers']
+        has_accept_encoding = any(k.lower() == 'accept-encoding' for k in headers)
+        skip_auto_headers = None
+        if self._compression == 'deflate':
+            if not has_accept_encoding:
+                headers['accept-encoding'] = 'deflate'
+        elif not has_accept_encoding:
+            skip_auto_headers = ['Accept-Encoding']
+
+        # Inner function to perform async write.
+        async def async_write():
+            post_kwargs = dict(self._aiohttp_kwargs)
+            if self._proxy is not None:
+                post_kwargs['proxy'] = self._proxy
+            if skip_auto_headers is not None:
+                post_kwargs['skip_auto_headers'] = skip_auto_headers
+            async with async_timeout.timeout(self._write_timeout):
+                self._http_req_resp = await self._client_session.post(url=self._url,
+                                                                      data=message['payload'],
+                                                                      headers=headers,
+                                                                      **post_kwargs)
+
+        # Execute the async write synchronously.
+        self._loop.run_until_complete(async_write())
+
+    def get_stream(self):
+        """Returns a synchronous file-like object for the HTTP response body."""
+        return AiohttpSyncStream(self._http_req_resp, self._loop, self._read_timeout)
+
+    @property
+    def content_type(self):
+        """Returns the Content-Type header of the HTTP response."""
+        if self._http_req_resp is not None:
+            return self._http_req_resp.headers.get('content-type', '')
+        return ''
+
+    @property
+    def status_code(self):
+        """Returns the HTTP status code of the response."""
+        if self._http_req_resp is not None:
+            return self._http_req_resp.status
+        return None
+
+    def read_body(self):
+        """Read the entire HTTP response body as bytes."""
+        return _run_read(self._loop, self._read_timeout, self._http_req_resp.read())
+
+    def evict_response(self):
+        """Close the current HTTP response and its underlying connection, evicting it from
+        aiohttp's connection pool. Used after a transport failure so a dead/half-closed
+        connection is discarded rather than returned to the pool for reuse."""
+        if self._http_req_resp is not None:
+            self._http_req_resp.close()
+            self._http_req_resp = None
+
+    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 (or not yet created).
+        return self._client_session is None or self._client_session.closed

gremlinpython-4.0.0.dev1/gremlin_python/driver/auth.py

@@ -0,0 +1,80 @@
+#
+# 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 base64
+
+
+def basic(username, password):
+    """Returns an interceptor that adds Basic auth to the request."""
+    def interceptor(request):
+        credentials = base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("utf-8")
+        request.headers['authorization'] = f"Basic {credentials}"
+
+    return interceptor
+
+
+def sigv4(region, service, credentials=None):
+    """Returns an interceptor that signs the request with AWS SigV4.
+
+    By default credentials are sourced from the standard AWS environment
+    variables (``AWS_ACCESS_KEY_ID``, ``AWS_SECRET_ACCESS_KEY`` and the optional
+    ``AWS_SESSION_TOKEN``). A custom credentials provider may be supplied via
+    ``credentials``; it accepts either:
+
+    * a callable returning a botocore ``Credentials`` object (or any object with
+      ``access_key``/``secret_key``/``token`` attributes), evaluated per request, or
+    * a botocore ``Credentials`` object (or ``Session``) used directly.
+
+    When no provider is given, signing falls back to the environment.
+    """
+    import os
+    from boto3 import Session
+    from botocore.auth import SigV4Auth
+    from botocore.awsrequest import AWSRequest
+
+    def _resolve_credentials():
+        if credentials is None:
+            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
+            )
+            return session.get_credentials()
+
+        provider = credentials() if callable(credentials) else credentials
+        # A botocore Session exposes get_credentials(); a Credentials object is
+        # already usable as-is.
+        if hasattr(provider, 'get_credentials'):
+            return provider.get_credentials()
+        return provider
+
+    def interceptor(request):
+        # Ensure body is serialized so we can sign it
+        body_bytes = request.serialize_body()
+
+        resolved = _resolve_credentials()
+
+        sigv4_request = AWSRequest(method=request.method, url=request.url, data=body_bytes)
+        SigV4Auth(resolved, service, region).add_auth(sigv4_request)
+        request.headers.update(dict(sigv4_request.headers))
+
+    return interceptor

gremlinpython-4.0.0.dev1/gremlin_python/driver/client.py

@@ -0,0 +1,209 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+import logging
+import warnings
+import queue
+from concurrent.futures import ThreadPoolExecutor
+
+from gremlin_python.driver import connection, request, serializer
+
+log = logging.getLogger("gremlinpython")
+
+# This is until concurrent.futures backport 3.1.0 release
+try:
+    from multiprocessing import cpu_count
+except ImportError:
+    # some platforms don't have multiprocessing
+    def cpu_count():
+        return None
+
+__author__ = 'David M. Brown (davebshow@gmail.com), Lyndon Bauto (lyndonb@bitquilltech.com)'
+
+
+class Client:
+
+    def __init__(self, url, traversal_source, max_connections=128, max_workers=None,
+                 response_serializer=None, interceptors=None, auth=None,
+                 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
+        # 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 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
+
+        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 = max_connections
+        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+        # Threadsafe queue
+        self._pool = queue.Queue()
+        self._fill_pool()
+
+    @property
+    def available_pool_size(self):
+        return self._pool.qsize()
+    
+    def response_serializer(self):
+        return self._response_serializer
+
+    @property
+    def executor(self):
+        return self._executor
+
+    @property
+    def traversal_source(self):
+        return self._traversal_source
+
+    def _fill_pool(self):
+        for i in range(self._max_connections):
+            conn = self._get_connection()
+            self._pool.put_nowait(conn)
+
+    def is_closed(self):
+        return self._closed
+
+    def close(self):
+        # prevent the Client from being closed more than once. it raises errors if new jobby jobs
+        # get submitted to the executor when it is shutdown
+        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)
+            conn.close()
+        self._executor.shutdown()
+        self._closed = True
+
+    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.
+
+        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 _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, parameters, request_options)
+
+    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}
+
+        # 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 != '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)