gremlinpython 3.6.4__tar.gz → 3.6.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gremlinpython
-Version: 3.6.4
+Version: 3.6.6
 Summary: Gremlin-Python for Apache TinkerPop
 Home-page: http://tinkerpop.apache.org
 License: Apache 2
@@ -59,16 +59,16 @@ from the Python shell looks like this:
 
     >>> from gremlin_python.process.anonymous_traversal import traversal
     >>> from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
-    >>> g = traversal().withRemote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
+    >>> g = traversal().with_remote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
 
 Once "g" has been created using a connection, it is then possible to start writing Gremlin traversals to query the
 remote graph:
 
-    >>> g.V().both()[1:3].toList()
+    >>> g.V().both()[1:3].to_list()
     [v[2], v[4]]
-    >>> g.V().both()[1].toList()
+    >>> g.V().both()[1].to_list()
     [v[2]]
-    >>> g.V().both().name.toList()
+    >>> g.V().both().name.to_list()
     [lop, vadas, josh, marko, marko, josh, peter, ripple, lop, marko, josh, lop]
 
 -----------------
@@ -101,7 +101,7 @@ Create Vertex
 
     def create_vertex(self, vid, vlabel):
         # default database cardinality is used when Cardinality argument is not specified
-        g.addV(vlabel).property(id, vid). \
+        g.add_v(vlabel).property(id, vid). \
           property(single, 'name', 'Apache'). \
           property('lastname', 'Tinkerpop'). \
           next()
@@ -112,13 +112,13 @@ Find Vertices
 .. code:: python
 
     def list_all(self, limit=500):
-        g.V().limit(limit).elementMap().toList()
+        g.V().limit(limit).element_map().to_list()
 
     def find_vertex(self, vid):
-        g.V(vid).elementMap().next()
+        g.V(vid).element_map().next()
 
     def list_by_label_name(self, vlabel, name):
-        g.V().has(vlabel, 'name', name).elementMap().toList()
+        g.V().has(vlabel, 'name', name).element_map().to_list()
 
 Update Vertex
 ^^^^^^^^^^^^^

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/README.rst

@@ -42,16 +42,16 @@ from the Python shell looks like this:
 
     >>> from gremlin_python.process.anonymous_traversal import traversal
     >>> from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
-    >>> g = traversal().withRemote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
+    >>> g = traversal().with_remote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
 
 Once "g" has been created using a connection, it is then possible to start writing Gremlin traversals to query the
 remote graph:
 
-    >>> g.V().both()[1:3].toList()
+    >>> g.V().both()[1:3].to_list()
     [v[2], v[4]]
-    >>> g.V().both()[1].toList()
+    >>> g.V().both()[1].to_list()
     [v[2]]
-    >>> g.V().both().name.toList()
+    >>> g.V().both().name.to_list()
     [lop, vadas, josh, marko, marko, josh, peter, ripple, lop, marko, josh, lop]
 
 -----------------
@@ -84,7 +84,7 @@ Create Vertex
 
     def create_vertex(self, vid, vlabel):
         # default database cardinality is used when Cardinality argument is not specified
-        g.addV(vlabel).property(id, vid). \
+        g.add_v(vlabel).property(id, vid). \
           property(single, 'name', 'Apache'). \
           property('lastname', 'Tinkerpop'). \
           next()
@@ -95,13 +95,13 @@ Find Vertices
 .. code:: python
 
     def list_all(self, limit=500):
-        g.V().limit(limit).elementMap().toList()
+        g.V().limit(limit).element_map().to_list()
 
     def find_vertex(self, vid):
-        g.V(vid).elementMap().next()
+        g.V(vid).element_map().next()
 
     def list_by_label_name(self, vlabel, name):
-        g.V().has(vlabel, 'name', name).elementMap().toList()
+        g.V().has(vlabel, 'name', name).element_map().to_list()
 
 Update Vertex
 ^^^^^^^^^^^^^

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/gremlin_python/__version__.py

@@ -16,5 +16,5 @@ KIND, either express or implied.  See the License for the
 specific language governing permissions and limitations
 under the License.
 '''
-version   = '3.6.4'
-timestamp = 1684346759
+version   = '3.6.6'
+timestamp = 1701718721

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/gremlin_python/driver/aiohttp/transport.py

@@ -138,3 +138,99 @@ class AiohttpTransport(AbstractBaseTransport):
     def closed(self):
         # Connection is closed if either the websocket or the client session is closed.
         return self._websocket.closed or self._client_session.closed
+
+
+class AiohttpHTTPTransport(AbstractBaseTransport):
+    nest_asyncio_applied = False
+
+    def __init__(self, call_from_event_loop=None, read_timeout=None, write_timeout=None, **kwargs):
+        if call_from_event_loop is not None and call_from_event_loop and not AiohttpTransport.nest_asyncio_applied:
+            """ 
+                The AiohttpTransport implementation uses the asyncio event loop. Because of this, it cannot be called 
+                within an event loop without nest_asyncio. If the code is ever refactored so that it can be called 
+                within an event loop this import and call can be removed. Without this, applications which use the 
+                event loop to call gremlin-python (such as Jupyter) will not work.
+            """
+            import nest_asyncio
+            nest_asyncio.apply()
+            AiohttpTransport.nest_asyncio_applied = True
+
+        # Start event loop and initialize client session and response to None
+        self._loop = asyncio.new_event_loop()
+        self._client_session = None
+        self._http_req_resp = None
+        self._enable_ssl = False
+
+        # Set all inner variables to parameters passed in.
+        self._aiohttp_kwargs = kwargs
+        self._write_timeout = write_timeout
+        self._read_timeout = read_timeout
+        if "ssl_options" in self._aiohttp_kwargs:
+            self._ssl_context = self._aiohttp_kwargs.pop("ssl_options")
+            self._enable_ssl = True
+
+    def __del__(self):
+        # Close will only actually close if things are left open, so this is safe to call.
+        # Clean up any connection resources and close the event loop.
+        self.close()
+
+    def connect(self, url, headers=None):
+        # Inner function to perform async connect.
+        async def async_connect():
+            # Start client session and use it to send all HTTP requests. Base url is the endpoint, headers are set here
+            # Base url can only parse basic url with no path, see https://github.com/aio-libs/aiohttp/issues/6647
+            if self._enable_ssl:
+                # ssl context is established through tcp connector
+                tcp_conn = aiohttp.TCPConnector(ssl_context=self._ssl_context)
+                self._client_session = aiohttp.ClientSession(connector=tcp_conn,
+                                                             base_url=url, headers=headers, loop=self._loop)
+            else:
+                self._client_session = aiohttp.ClientSession(base_url=url, headers=headers, loop=self._loop)
+
+        # Execute the async connect synchronously.
+        self._loop.run_until_complete(async_connect())
+
+    def write(self, message):
+        # Inner function to perform async write.
+        async def async_write():
+            basic_auth = None
+            # basic password authentication for https connections
+            if message['auth']:
+                basic_auth = aiohttp.BasicAuth(message['auth']['username'], message['auth']['password'])
+            async with async_timeout.timeout(self._write_timeout):
+                self._http_req_resp = await self._client_session.post(url="/gremlin",
+                                                                      auth=basic_auth,
+                                                                      data=message['payload'],
+                                                                      headers=message['headers'],
+                                                                      **self._aiohttp_kwargs)
+
+        # Execute the async write synchronously.
+        self._loop.run_until_complete(async_write())
+
+    def read(self):
+        # Inner function to perform async read.
+        async def async_read():
+            async with async_timeout.timeout(self._read_timeout):
+                return await self._http_req_resp.read()
+
+        return self._loop.run_until_complete(async_read())
+
+    def close(self):
+        # Inner function to perform async close.
+        async def async_close():
+            if self._client_session is not None and not self._client_session.closed:
+                await self._client_session.close()
+                self._client_session = None
+
+        # If the loop is not closed (connection hasn't already been closed)
+        if not self._loop.is_closed():
+            # Execute the async close synchronously.
+            self._loop.run_until_complete(async_close())
+
+            # Close the event loop.
+            self._loop.close()
+
+    @property
+    def closed(self):
+        # Connection is closed when client session is closed.
+        return self._client_session.closed

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/gremlin_python/driver/client.py

@@ -19,6 +19,7 @@
 import logging
 import warnings
 import queue
+import re
 from concurrent.futures import ThreadPoolExecutor
 
 from gremlin_python.driver import connection, protocol, request, serializer
@@ -45,12 +46,16 @@ class Client:
                  kerberized_service="", headers=None, session=None,
                  enable_user_agent_on_connect=True, **transport_kwargs):
         log.info("Creating Client with url '%s'", url)
+
+        # check via url that we are using http protocol
+        self._use_http = re.search('^http', url)
+
         self._closed = False
         self._url = url
         self._headers = headers
         self._enable_user_agent_on_connect = enable_user_agent_on_connect
         self._traversal_source = traversal_source
-        if "max_content_length" not in transport_kwargs:
+        if not self._use_http and "max_content_length" not in transport_kwargs:
             transport_kwargs["max_content_length"] = 10 * 1024 * 1024
         if message_serializer is None:
             message_serializer = serializer.GraphBinarySerializersV1()
@@ -63,21 +68,31 @@ class Client:
         if transport_factory is None:
             try:
                 from gremlin_python.driver.aiohttp.transport import (
-                    AiohttpTransport)
+                    AiohttpTransport, AiohttpHTTPTransport)
             except ImportError:
                 raise Exception("Please install AIOHTTP or pass "
                                 "custom transport factory")
             else:
                 def transport_factory():
-                    return AiohttpTransport(**transport_kwargs)
+                    if self._use_http:
+                        return AiohttpHTTPTransport(**transport_kwargs)
+                    else:
+                        return AiohttpTransport(**transport_kwargs)
         self._transport_factory = transport_factory
         if protocol_factory is None:
-            def protocol_factory(): return protocol.GremlinServerWSProtocol(
-                self._message_serializer,
-                username=self._username,
-                password=self._password,
-                kerberized_service=kerberized_service,
-                max_content_length=transport_kwargs["max_content_length"])
+            def protocol_factory():
+                if self._use_http:
+                    return protocol.GremlinServerHTTPProtocol(
+                        self._message_serializer,
+                        username=self._username,
+                        password=self._password)
+                else:
+                    return protocol.GremlinServerWSProtocol(
+                        self._message_serializer,
+                        username=self._username,
+                        password=self._password,
+                        kerberized_service=kerberized_service,
+                        max_content_length=transport_kwargs["max_content_length"])
         self._protocol_factory = protocol_factory
         if self._session_enabled:
             if pool_size is None:
@@ -161,6 +176,9 @@ class Client:
         return self.submit_async(message, bindings, request_options)
 
     def submit_async(self, message, bindings=None, request_options=None):
+        if self.is_closed():
+            raise Exception("Client is closed")
+
         log.debug("message '%s'", str(message))
         args = {'gremlin': message, 'aliases': {'g': self._traversal_source}}
         processor = ''

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/gremlin_python/driver/connection.py

@@ -61,6 +61,7 @@ class Connection:
         request_id = str(uuid.uuid4())
         if request_message.args.get("requestId"):
             request_id = request_message.args.get("requestId")
+            uuid.UUID(request_id) # Checks for proper UUID or else server will return an error.
         result_set = resultset.ResultSet(queue.Queue(), request_id)
         self._results[request_id] = result_set
         # Create write task

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/gremlin_python/driver/protocol.py

@@ -16,6 +16,7 @@
 # specific language governing permissions and limitations
 # under the License.
 #
+import json
 import logging
 import abc
 import base64
@@ -25,6 +26,8 @@ import struct
 
 from gremlin_python.driver import request
 from gremlin_python.driver.resultset import ResultSet
+from gremlin_python.process.translator import Translator
+from gremlin_python.process.traversal import Bytecode
 
 log = logging.getLogger("gremlinpython")
 
@@ -63,7 +66,6 @@ class AbstractBaseProtocol(metaclass=abc.ABCMeta):
 
 
 class GremlinServerWSProtocol(AbstractBaseProtocol):
-
     QOP_AUTH_BIT = 1
     _kerberos_context = None
     _max_content_length = 10 * 1024 * 1024
@@ -133,7 +135,7 @@ class GremlinServerWSProtocol(AbstractBaseProtocol):
             # This message is going to be huge and kind of hard to read, but in the event of an error,
             # it can provide invaluable info, so space it out appropriately.
             log.error("\r\nReceived error message '%s'\r\n\r\nWith results dictionary '%s'",
-                          str(message), str(results_dict))
+                      str(message), str(results_dict))
             del results_dict[request_id]
             raise GremlinServerError(message['status'])
 
@@ -185,8 +187,71 @@ class GremlinServerWSProtocol(AbstractBaseProtocol):
         name_length = len(self._username)
         fmt = '!I' + str(name_length) + 's'
         word = self.QOP_AUTH_BIT << 24 | self._max_content_length
-        out = struct.pack(fmt, word, self._username.encode("utf-8"),)
+        out = struct.pack(fmt, word, self._username.encode("utf-8"), )
         encoded = base64.b64encode(out).decode('ascii')
         kerberos.authGSSClientWrap(self._kerberos_context, encoded)
         auth = kerberos.authGSSClientResponse(self._kerberos_context)
         return request.RequestMessage('', 'authentication', {'sasl': auth})
+
+
+class GremlinServerHTTPProtocol(AbstractBaseProtocol):
+
+    def __init__(self,
+                 message_serializer,
+                 username='', password=''):
+        self._message_serializer = message_serializer
+        self._username = username
+        self._password = password
+
+    def connection_made(self, transport):
+        super(GremlinServerHTTPProtocol, self).connection_made(transport)
+
+    def write(self, request_id, request_message):
+
+        basic_auth = {}
+        if self._username and self._password:
+            basic_auth['username'] = self._username
+            basic_auth['password'] = self._password
+
+        content_type = str(self._message_serializer.version, encoding='utf-8')
+        message = {
+            'headers': {'CONTENT-TYPE': content_type,
+                        'ACCEPT': content_type},
+            'payload': self._message_serializer.serialize_message(request_id, request_message),
+            'auth': basic_auth
+        }
+
+        self._transport.write(message)
+
+    def data_received(self, message, results_dict):
+        # if Gremlin Server cuts off then we get a None for the message
+        if message is None:
+            log.error("Received empty message from server.")
+            raise GremlinServerError({'code': 500,
+                                      'message': 'Server disconnected - please try to reconnect', 'attributes': {}})
+
+        message = self._message_serializer.deserialize_message(message)
+        request_id = message['requestId']
+        result_set = results_dict[request_id] if request_id in results_dict else ResultSet(None, None)
+        status_code = message['status']['code']
+        aggregate_to = message['result']['meta'].get('aggregateTo', 'list')
+        data = message['result']['data']
+        result_set.aggregate_to = aggregate_to
+
+        if status_code == 204:
+            result_set.stream.put_nowait([])
+            del results_dict[request_id]
+            return status_code
+        elif status_code in [200, 206]:
+            result_set.stream.put_nowait(data)
+            if status_code == 200:
+                result_set.status_attributes = message['status']['attributes']
+                del results_dict[request_id]
+            return status_code
+        else:
+            # This message is going to be huge and kind of hard to read, but in the event of an error,
+            # it can provide invaluable info, so space it out appropriately.
+            log.error("\r\nReceived error message '%s'\r\n\r\nWith results dictionary '%s'",
+                      str(message), str(results_dict))
+            del results_dict[request_id]
+            raise GremlinServerError(message['status'])

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/gremlin_python/driver/serializer.py

@@ -17,6 +17,7 @@
 # under the License.
 #
 
+import base64
 import logging
 import struct
 import uuid
@@ -156,7 +157,8 @@ class GraphSONMessageSerializer(object):
         return message
 
     def deserialize_message(self, message):
-        msg = json.loads(message.decode('utf-8'))
+        # for parsing string message via HTTP connections
+        msg = json.loads(message if isinstance(message, str) else message.decode('utf-8'))
         return self._graphson_reader.to_object(msg)
 
 
@@ -268,7 +270,8 @@ class GraphBinarySerializersV1(object):
         return bytes(ba)
 
     def deserialize_message(self, message):
-        b = io.BytesIO(message)
+        # for parsing string message via HTTP connections
+        b = io.BytesIO(base64.b64decode(message) if isinstance(message, str) else message)
 
         b.read(1)  # version
 

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/gremlin_python/driver/useragent.py

@@ -18,20 +18,16 @@
 #
 import platform
 
+gremlin_version = "3.6.6"  # DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
 
 def _generate_user_agent():
     application_name = "NotAvailable"
-    try:
-        from gremlin_python import __version__
-        driver_version = __version__.version.replace(" ", "_")
-    except ImportError:
-        driver_version = "NotAvailable"
     runtime_version = platform.python_version().replace(" ", "_")
     os_name = platform.system().replace(" ", "_")
     os_version = platform.release().replace(" ", "_")
     architecture = platform.machine().replace(" ", "_")
     user_agent = "{appName} Gremlin-Python.{driverVersion} {runtimeVersion} {osName}.{osVersion} {cpuArch}".format(
-                    appName=application_name, driverVersion=driver_version, runtimeVersion=runtime_version,
+                    appName=application_name, driverVersion=gremlin_version, runtimeVersion=runtime_version,
                     osName=os_name, osVersion=os_version, cpuArch=architecture)
 
     return user_agent

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/gremlin_python/process/graph_traversal.py

@@ -134,7 +134,7 @@ class GraphTraversalSource(object):
         val = True if v is None else v
         if options_strategy is None:
             options_strategy = OptionsStrategy({k: val})
-            source = self.withStrategies(options_strategy)
+            source = self.with_strategies(options_strategy)
         else:
             options_strategy[1].configuration[k] = val
 
@@ -1587,7 +1587,7 @@ def V(*args):
 
 
 def addE(*args):
-    return __.addE(*args)
+    return __.add_e(*args)
 
 
 def add_e(*args):
@@ -1595,7 +1595,7 @@ def add_e(*args):
 
 
 def addV(*args):
-    return __.addV(*args)
+    return __.add_v(*args)
 
 
 def add_v(*args):
@@ -1623,7 +1623,7 @@ def both(*args):
 
 
 def bothE(*args):
-    return __.bothE(*args)
+    return __.both_e(*args)
 
 
 def both_e(*args):
@@ -1631,7 +1631,7 @@ def both_e(*args):
 
 
 def bothV(*args):
-    return __.bothV(*args)
+    return __.both_v(*args)
 
 
 def both_v(*args):
@@ -1671,7 +1671,7 @@ def count(*args):
 
 
 def cyclicPath(*args):
-    return __.cyclicPath(*args)
+    return __.cyclic_path(*args)
 
 
 def cyclic_path(*args):
@@ -1691,7 +1691,7 @@ def element(*args):
 
 
 def elementMap(*args):
-    return __.elementMap(*args)
+    return __.element_map(*args)
 
 
 def element_map(*args):
@@ -1711,7 +1711,7 @@ def filter_(*args):
 
 
 def flatMap(*args):
-    return __.flatMap(*args)
+    return __.flat_map(*args)
 
 
 def flat_map(*args):
@@ -1727,7 +1727,7 @@ def group(*args):
 
 
 def groupCount(*args):
-    return __.groupCount(*args)
+    return __.group_count(*args)
 
 
 def group_count(*args):
@@ -1739,7 +1739,7 @@ def has(*args):
 
 
 def hasId(*args):
-    return __.hasId(*args)
+    return __.has_id(*args)
 
 
 def has_id(*args):
@@ -1747,7 +1747,7 @@ def has_id(*args):
 
 
 def hasKey(*args):
-    return __.hasKey(*args)
+    return __.has_key_(*args)
 
 
 def has_key_(*args):
@@ -1755,7 +1755,7 @@ def has_key_(*args):
 
 
 def hasLabel(*args):
-    return __.hasLabel(*args)
+    return __.has_label(*args)
 
 
 def has_label(*args):
@@ -1763,7 +1763,7 @@ def has_label(*args):
 
 
 def hasNot(*args):
-    return __.hasNot(*args)
+    return __.has_not(*args)
 
 
 def has_not(*args):
@@ -1771,7 +1771,7 @@ def has_not(*args):
 
 
 def hasValue(*args):
-    return __.hasValue(*args)
+    return __.has_value(*args)
 
 
 def has_value(*args):
@@ -1787,7 +1787,7 @@ def identity(*args):
 
 
 def inE(*args):
-    return __.inE(*args)
+    return __.in_e(*args)
 
 
 def in_e(*args):
@@ -1795,7 +1795,7 @@ def in_e(*args):
 
 
 def inV(*args):
-    return __.inV(*args)
+    return __.in_v(*args)
 
 
 def in_v(*args):
@@ -1887,7 +1887,7 @@ def order(*args):
 
 
 def otherV(*args):
-    return __.otherV(*args)
+    return __.other_v(*args)
 
 
 def other_v(*args):
@@ -1899,7 +1899,7 @@ def out(*args):
 
 
 def outE(*args):
-    return __.outE(*args)
+    return __.out_e(*args)
 
 
 def out_e(*args):
@@ -1907,7 +1907,7 @@ def out_e(*args):
 
 
 def outV(*args):
-    return __.outV(*args)
+    return __.out_v(*args)
 
 
 def out_v(*args):
@@ -1931,7 +1931,7 @@ def property(*args):
 
 
 def propertyMap(*args):
-    return __.propertyMap(*args)
+    return __.property_map(*args)
 
 
 def property_map(*args):
@@ -1959,7 +1959,7 @@ def select(*args):
 
 
 def sideEffect(*args):
-    return __.sideEffect(*args)
+    return __.side_effect(*args)
 
 
 def side_effect(*args):
@@ -1967,7 +1967,7 @@ def side_effect(*args):
 
 
 def simplePath(*args):
-    return __.simplePath(*args)
+    return __.simple_path(*args)
 
 
 def simple_path(*args):
@@ -1995,7 +1995,7 @@ def tail(*args):
 
 
 def timeLimit(*args):
-    return __.timeLimit(*args)
+    return __.time_limit(*args)
 
 
 def time_limit(*args):
@@ -2011,7 +2011,7 @@ def to(*args):
 
 
 def toE(*args):
-    return __.toE(*args)
+    return __.to_e(*args)
 
 
 def to_e(*args):
@@ -2019,7 +2019,7 @@ def to_e(*args):
 
 
 def toV(*args):
-    return __.toV(*args)
+    return __.to_v(*args)
 
 
 def to_v(*args):
@@ -2047,7 +2047,7 @@ def value(*args):
 
 
 def valueMap(*args):
-    return __.valueMap(*args)
+    return __.value_map(*args)
 
 
 def value_map(*args):

gremlinpython-3.6.6/gremlin_python/process/translator.py

@@ -0,0 +1,297 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+"""
+Class that can turn traversals back into Gremlin Groovy format text queries.
+Those queries can then be run in the Gremlin console or using the GLV submit(<String>) API or
+sent to any TinkerPop compliant HTTP endpoint.
+"""
+__author__ = 'Kelvin R. Lawrence (gfxman)'
+
+import math
+import numbers
+import re
+
+from gremlin_python.process.traversal import *
+from gremlin_python.process.strategies import *
+from gremlin_python.structure.graph import Vertex, Edge, VertexProperty
+from datetime import datetime
+
+
+class Translator:
+    """
+    Turn a bytecode object back into a textual query (Gremlin Groovy script).
+    """
+
+    # Dictionary used to reverse-map token IDs to strings
+    options = {
+        WithOptions.tokens: 'tokens',
+        WithOptions.none: 'none',
+        WithOptions.ids: 'ids',
+        WithOptions.labels: 'labels',
+        WithOptions.keys: 'keys',
+        WithOptions.values: 'values',
+        WithOptions.all: 'all',
+        WithOptions.indexer: 'indexer',
+        WithOptions.list: 'list',
+        WithOptions.map: 'map'
+    }
+
+    conn_p = ['and', 'or']
+
+    def __init__(self, traversal_source=None):
+        self.traversal_source = traversal_source
+
+    def get_traversal_source(self):
+        return self.traversal_source
+
+    def get_target_language(self):
+        return "gremlin-groovy"
+
+    def of(self, traversal_source):
+        self.traversal_source = traversal_source
+        return self
+
+    # Do any needed special processing for the representation
+    # of strings and dates and boolean.
+    def fixup(self, v):
+        if isinstance(v, str):
+            return f'{v!r}'  # use repr() format for canonical string rep
+        elif type(v) == datetime:
+            return self.process_date(v)
+        elif type(v) == bool:
+            return 'true' if v else 'false'
+        elif isinstance(v, numbers.Number):
+            return self.process_number(v)
+        elif isinstance(v, set):
+            return f'[{str(v)[1:-1]}]'
+        elif isinstance(v, P):
+            return self.process_predicate(v)
+        elif type(v) == Vertex:
+            return self.process_vertex(v)
+        elif type(v) == Edge:
+            return self.process_edge(v)
+        elif type(v) in [Merge]:  # on_create on_match out_v in_v
+            tmp = str(v)
+            return f'{tmp.split("_")[0]}{tmp.split("_")[1].capitalize()}' if tmp.find('_') else tmp
+        elif v is None:
+            return 'null'
+        else:
+            return str(v)
+
+    # Turn a Python datetime into the equivalent new Date(...)
+    def process_date(self, date):
+        y = date.year - 1900
+        mo = date.month
+        d = date.day
+        h = date.hour
+        mi = date.minute
+        s = date.second
+        return f'new Date({y},{mo},{d},{h},{mi},{s})'
+
+    # Do special processing needed to format predicates that come in
+    # such as "gt(a)" correctly.
+    def process_predicate(self, p):
+        res = ''
+        if p.operator in self.conn_p:
+            res += f'{self.process_predicate(p.value)}.{p.operator}({self.process_predicate(p.other)})'
+        else:
+            res += f'{self.process_p_value(p)}'
+        return res
+
+    # process the value of the predicates
+    def process_p_value(self, p):
+        res = str(p).split('(')[0] + '('
+        if type(p.value) == list:
+            res += '['
+            for v in p.value:
+                res += self.fixup(v) + ','
+            res = (res[0:-1] + ']') if len(p.value) > 0 else (res + ']')
+        else:
+            res += self.fixup(p.value)
+            if p.other is not None:
+                res += f',{self.fixup(p.other)}'
+        res += ')'
+        return res
+
+    # Special processing to handle strategies
+    def process_strategy(self, s):
+        c = 0
+        res = ''
+        # if parameter is empty, only pass class name (referenced GroovyTranslator.java)
+        if not s.configuration:
+            res += s.strategy_name
+        else:
+            res = f'new {str(s)}('
+            for key in s.configuration:
+                res += ',' if c > 0 else ''
+                res += key + ':'
+                val = s.configuration[key]
+                if isinstance(val, Traversal):
+                    res += self.translate(val.bytecode, child=True)
+                else:
+                    res += self.fixup(val)
+                c += 1
+            res += ')'
+        return res
+        pass
+
+    # Special processing to handle vertices
+    def process_vertex(self, vertex):
+        return f'new ReferenceVertex({self.fixup(vertex.id)},\'{vertex.label}\')'
+
+    # Special processing to handle edges
+    def process_edge(self, edge):
+        return f'new ReferenceEdge({str(edge.id)},\'{edge.label}\',' \
+               f'new ReferenceVertex({str(edge.inV.id)},\'{edge.inV.label}\'),' \
+               f'new ReferenceVertex({str(edge.outV.id)},\'{edge.outV.label}\'))'
+
+    # Special processing to handle vertex property
+    def process_vertex_property(self, vp):
+        return f'new ReferenceVertexProperty({str(vp.id)},\'{vp.label}\',{self.fixup(vp.value)})'
+
+    # Special processing to handle lambda
+    def process_lambda(self, lam):
+        lambda_result = lam()
+        script = lambda_result if isinstance(lambda_result, str) else lambda_result[0]
+        return f'{script}' if re.match(r"^\{.*\}$", script, flags=re.DOTALL) else f'{{{script}}}'
+
+    def process_dict(self, d):
+        c = 0
+        res = '['
+        if len(d) == 0:
+            res += ':'
+        else:
+            for k, v in d.items():
+                wrap = not isinstance(k, str)
+                res += ',' if c > 0 else ''
+                res += '(' if wrap else ''
+                res += self.fixup(k)
+                res += ')' if wrap else ''
+                res += f':{self.fixup(v)}'
+                c += 1
+        res += ']'
+        return res
+
+    def process_number(self, n):
+        if isinstance(n, float):
+            # converting floats into doubles for script since python doesn't distinguish and java defaults to double
+            if math.isnan(n):
+                return "Double.NaN"
+            elif math.isinf(n) and n > 0:
+                return "Double.POSITIVE_INFINITY"
+            elif math.isinf(n) and n < 0:
+                return "Double.NEGATIVE_INFINITY"
+            else:
+                return f'{n}d'
+        return f'{n}'
+
+    def process_list(self, l):
+        c = 0
+        res = '['
+        for i in l:
+            res += ',' if c > 0 else ''
+            res += self.fixup(i)
+            c += 1
+        res += ']'
+        return res
+
+    # Special processing to handle bindings inside of traversals
+    def process_binding(self, binding):
+        return f'Bindings.instance().of(\'{binding.key}\', {str(binding.value)})'
+
+    # Main driver of the translation. Different parts of
+    # a Traversal are handled appropriately.
+    def do_translation(self, step):
+        script = ''
+        params = step[1:]
+        script += '.' + step[0] + '('
+        if len(params) > 0:
+            c = 0
+            with_opts = False
+            is_merge_op = (step[0] == 'mergeV') or (step[0] == 'mergeE')
+            for p in params:
+                script += ',' if c > 0 else ''
+                if with_opts:
+                    script += f'WithOptions.{self.options[p]}'
+                elif type(p) == Bytecode:
+                    script += self.translate(p, True)
+                elif isinstance(p, P):
+                    script += self.process_predicate(p)
+                elif type(p) == Vertex:
+                    script += self.process_vertex(p)
+                elif type(p) == Edge:
+                    script += self.process_edge(p)
+                elif type(p) == VertexProperty:
+                    script += self.process_vertex_property(p)
+                elif type(p) in [Cardinality, Pop, Operator, Scope, T]:
+                    tmp = str(p)
+                    script += tmp[0:-1] if tmp.endswith('_') else tmp
+                elif type(p) in [Merge]:  # on_create on_match out_v in_v
+                    is_merge_op = True
+                    tmp = str(p)
+                    script += f'{tmp.split("_")[0]}{tmp.split("_")[1].capitalize()}' if tmp.find('_') else tmp
+                elif isinstance(p, TraversalStrategy):  # this will capture all strategies
+                    script += self.process_strategy(p)
+                elif type(p) == datetime:
+                    script += self.process_date(p)
+                elif p == WithOptions.tokens:
+                    script += 'WithOptions.tokens'
+                    with_opts = True
+                elif isinstance(p, str):
+                    script += f'{p!r}'  # use repr() format for canonical string rep
+                elif type(p) == bool:
+                    script += 'true' if p else 'false'
+                elif isinstance(p, type(lambda: None)) and p.__name__ == (lambda: None).__name__:
+                    script += self.process_lambda(p)
+                elif type(p) == Binding:
+                    script += self.process_binding(p)
+                elif p is None:
+                    script += '(Traversal) null' if is_merge_op else 'null'
+                elif isinstance(p, type):
+                    script += p.__name__
+                elif isinstance(p, dict):
+                    script += self.process_dict(p)
+                elif isinstance(p, numbers.Number):
+                    script += self.process_number(p)
+                elif isinstance(p, set):
+                    script += f'[{str(p)[1:-1]}] as Set' if len(p) > 0 else '[] as Set'
+                elif isinstance(p, list):
+                    script += self.process_list(p)
+                else:
+                    script += str(p)
+                c += 1
+        script += ')'
+        return script
+
+    # Translation starts here. There are two main parts to a 
+    # traversal. Source instructions such as "withSideEffect"
+    # and "withStrategies", and step instructions such as 
+    # "addV" and "repeat". If child is True we will generate
+    # anonymous traversal style syntax.
+    def translate(self, bytecode, child=False):
+        script = '__' if child else self.traversal_source
+
+        for step in bytecode.source_instructions:
+            script += self.do_translation(step)
+
+        for step in bytecode.step_instructions:
+            script += self.do_translation(step)
+
+        return script

{gremlinpython-3.6.4 → gremlinpython-3.6.6}/gremlin_python/process/traversal.py

@@ -77,7 +77,7 @@ class Traversal(object):
     def iterate(self):
         self.bytecode.add_step("none")
         while True:
-            try: self.nextTraverser()
+            try: self.next_traverser()
             except StopIteration: return self
 
     def nextTraverser(self):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gremlinpython
-Version: 3.6.4
+Version: 3.6.6
 Summary: Gremlin-Python for Apache TinkerPop
 Home-page: http://tinkerpop.apache.org
 License: Apache 2
@@ -59,16 +59,16 @@ from the Python shell looks like this:
 
     >>> from gremlin_python.process.anonymous_traversal import traversal
     >>> from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
-    >>> g = traversal().withRemote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
+    >>> g = traversal().with_remote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
 
 Once "g" has been created using a connection, it is then possible to start writing Gremlin traversals to query the
 remote graph:
 
-    >>> g.V().both()[1:3].toList()
+    >>> g.V().both()[1:3].to_list()
     [v[2], v[4]]
-    >>> g.V().both()[1].toList()
+    >>> g.V().both()[1].to_list()
     [v[2]]
-    >>> g.V().both().name.toList()
+    >>> g.V().both().name.to_list()
     [lop, vadas, josh, marko, marko, josh, peter, ripple, lop, marko, josh, lop]
 
 -----------------
@@ -101,7 +101,7 @@ Create Vertex
 
     def create_vertex(self, vid, vlabel):
         # default database cardinality is used when Cardinality argument is not specified
-        g.addV(vlabel).property(id, vid). \
+        g.add_v(vlabel).property(id, vid). \
           property(single, 'name', 'Apache'). \
           property('lastname', 'Tinkerpop'). \
           next()
@@ -112,13 +112,13 @@ Find Vertices
 .. code:: python
 
     def list_all(self, limit=500):
-        g.V().limit(limit).elementMap().toList()
+        g.V().limit(limit).element_map().to_list()
 
     def find_vertex(self, vid):
-        g.V(vid).elementMap().next()
+        g.V(vid).element_map().next()
 
     def list_by_label_name(self, vlabel, name):
-        g.V().has(vlabel, 'name', name).elementMap().toList()
+        g.V().has(vlabel, 'name', name).element_map().to_list()
 
 Update Vertex
 ^^^^^^^^^^^^^

gremlinpython-3.6.4/gremlin_python/process/translator.py

@@ -1,173 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-"""
-Class that can turn traversals back into Gremlin Groovy format text queries.
-Those queries can then be run in the Gremlin console or using the GLV submit(<String>) API or
-sent to any TinkerPop compliant HTTP endpoint.
-"""
-__author__ = 'Kelvin R. Lawrence (gfxman)'
-
-from gremlin_python.process.graph_traversal import __
-from gremlin_python.process.anonymous_traversal import traversal
-from gremlin_python.process.traversal import *
-from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
-from gremlin_python.process.strategies import *
-from datetime import datetime
-
-
-class Translator:
-    """
-    Turn a bytecode object back into a textual query (Gremlin Groovy script).
-    """
-
-    # Dictionary used to reverse-map token IDs to strings
-    options = {
-      WithOptions.tokens: 'tokens',
-      WithOptions.none: 'none',
-      WithOptions.ids: 'ids',
-      WithOptions.labels: 'labels',
-      WithOptions.keys: 'keys',
-      WithOptions.values: 'values',
-      WithOptions.all: 'all',
-      WithOptions.indexer: 'indexer',
-      WithOptions.list: 'list',
-      WithOptions.map: 'map'                           
-    }
-
-    def __init__(self, traversal_source=None):
-        self.traversal_source = traversal_source
-
-    def get_traversal_source(self):
-        return self.traversal_source
-
-    def get_target_language(self):
-        return "gremlin-groovy"
-
-    def of(self,traversal_source):
-        self.traversal_source = traversal_source
-        return self
-
-    # Do any needed special processing for the representation
-    # of strings and dates.
-    def fixup(self, v):
-        if type(v) == str:
-            return f'\'{v}\''
-        elif type(v) == datetime:
-            return self.process_date(v)
-        else:
-            return str(v)
-    
-    # Turn a Python datetime into the equivalent new Date(...)
-    def process_date(self, date):
-        y = date.year - 1900
-        mo = date.month
-        d = date.day
-        h = date.hour
-        mi = date.minute
-        s = date.second
-        return f'new Date({y},{mo},{d},{h},{mi},{s})'
-
-    # Do special processing needed to format predicates that come in
-    # such as "gt(a)" correctly.
-    def process_predicate(self, p):
-        res = str(p).split('(')[0] + '('
-
-        if type(p.value) == list:
-            res += '['
-            for v in p.value:
-                res += self.fixup(v) + ','
-            res = res[0:-1] + ']'
-        else:
-            res += self.fixup(p.value)
-            if p.other is not None:
-                res+= ',' + self.fixup(p.other)
-        res += ')'
-        return res
-
-    # Special processing to handle strategies
-    def process_strategy(self, s):
-        c = 0
-        res = f'new {str(s)}('
-        for key in s.configuration:
-            res += ',' if c > 0 else ''
-            res += key + ':'
-            val = s.configuration[key]
-            if isinstance(val, Traversal):
-                res += self.translate(val.bytecode, child=True)
-            else:
-                res += self.fixup(val)
-            c += 1
-        res += ')'
-        return res
-        pass
-
-    # Main driver of the translation. Different parts of
-    # a Traversal are handled appropriately.
-    def do_translation(self, step):
-        script = ''
-        params = step[1:]
-        script += '.' + step[0] + '('
-        if len(params) > 0:
-            c = 0
-            with_opts = False
-            for p in params:
-                script += ',' if c > 0 else ''
-                if with_opts:
-                  script += f'WithOptions.{self.options[p]}'
-                elif type(p) == Bytecode:
-                    script += self.translate(p, True)
-                elif type(p) == P:
-                    script += self.process_predicate(p)
-                elif type(p) in [Cardinality, Pop, Operator]:
-                    tmp = str(p)
-                    script += tmp[0:-1] if tmp.endswith('_') else tmp 
-                elif type(p) in [ReadOnlyStrategy, SubgraphStrategy, VertexProgramStrategy,
-                                 OptionsStrategy, PartitionStrategy]:
-                    script += self.process_strategy(p)
-                elif type(p) == datetime:
-                    script += self.process_date(p)
-                elif p == WithOptions.tokens:
-                    script += 'WithOptions.tokens'
-                    with_opts = True
-                elif type(p) == str:
-                    script += f'\'{p}\''
-                elif type(p) == bool:
-                    script += 'true' if p else 'false'
-                else:
-                    script += str(p)
-                c += 1
-        script += ')'
-        return script
-
-    # Translation starts here. There are two main parts to a 
-    # traversal. Source instructions such as "withSideEffect"
-    # and "withStrategies", and step instructions such as 
-    # "addV" and "repeat". If child is True we will generate
-    # anonymous traversal style syntax.
-    def translate(self, bytecode, child=False):
-        script = '__' if child else self.traversal_source
-        
-        for step in bytecode.source_instructions:
-            script += self.do_translation(step)
-
-        for step in bytecode.step_instructions:
-            script += self.do_translation(step)
-       
-        return script