gremlinpython 3.7.0__tar.gz → 3.7.2__tar.gz

gremlinpython-3.7.2/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.0/gremlinpython.egg-info → gremlinpython-3.7.2}/PKG-INFO

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

{gremlinpython-3.7.0 → gremlinpython-3.7.2}/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.0'
-timestamp = 1691178354
+version   = '3.7.2'
+timestamp = 1713201447

{gremlinpython-3.7.0 → gremlinpython-3.7.2}/gremlin_python/driver/aiohttp/transport.py

@@ -138,3 +138,101 @@ 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 {"content": await self._http_req_resp.read(),
+                        "ok": self._http_req_resp.ok,
+                        "status": self._http_req_resp.status}
+
+        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.7.0 → gremlinpython-3.7.2}/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.7.0 → gremlinpython-3.7.2}/gremlin_python/driver/connection.py

@@ -58,9 +58,11 @@ class Connection:
     def write(self, request_message):
         if not self._inited:
             self.connect()
-        request_id = str(uuid.uuid4())
         if request_message.args.get("requestId"):
-            request_id = 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
         # Create write task

{gremlinpython-3.7.0 → gremlinpython-3.7.2}/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,73 @@ 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, response, results_dict):
+        # if Gremlin Server cuts off then we get a None for the message
+        if response is None:
+            log.error("Received empty message from server.")
+            raise GremlinServerError({'code': 500,
+                                      'message': 'Server disconnected - please try to reconnect', 'attributes': {}})
+
+        if response['ok']:
+            message = self._message_serializer.deserialize_message(response['content'])
+            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(response['content']), str(results_dict))
+            body = json.loads(response['content'])
+            del results_dict[body['requestId']]
+            raise GremlinServerError({'code': response['status'], 'message': body['message'], 'attributes': {}})

{gremlinpython-3.7.0 → gremlinpython-3.7.2}/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)
 
 
@@ -238,7 +240,7 @@ class GraphBinarySerializersV1(object):
     def finalize_message(self, message, mime_len, mime_type):
         ba = bytearray()
 
-        request_id = uuid.UUID(message['requestId'])
+        request_id = uuid.UUID(str(message['requestId']))
         ba.extend(self.header_pack(mime_len, mime_type, 0x81,
                                    (request_id.int >> 64) & self.max_int64, request_id.int & self.max_int64))
 
@@ -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.7.0 → gremlinpython-3.7.2}/gremlin_python/driver/useragent.py

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