[ 
https://issues.apache.org/jira/browse/TINKERPOP-2774?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18146768#comment-18146768
 ] 

ASF GitHub Bot commented on TINKERPOP-2774:
-------------------------------------------

masterhugo commented on code in PR #3527:
URL: https://github.com/apache/tinkerpop/pull/3527#discussion_r4615305702


##########
gremlin-python/src/main/python/gremlin_python/driver/async_graph_traversal.py:
##########
@@ -0,0 +1,489 @@
+#
+# 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.
+#
+"""Experimental API. This API may have breaking changes or be removed in a 
subsequent minor release.
+
+Async traversal layer for gremlin-python.
+
+Async counterpart for the standard traversal() factory::
+
+    async with AsyncDriverRemoteConnection("ws://localhost:8182/gremlin", "g") 
as rc:
+        g = async_traversal().with_remote(rc)
+
+        names  = await g.V().has_label("person").values("name").to_list()
+        count  = await g.V().count().next()
+        await  g.add_v("person").property("name", "saturn").iterate()
+
+        async with await g.tx() as gtx:
+            await gtx.add_v("person").property("name", "pluto").iterate()
+            # commits on clean exit, rolls back on exception
+"""
+import asyncio
+import copy
+import logging
+
+from gremlin_python.process.graph_traversal import GraphTraversal, 
GraphTraversalSource
+from gremlin_python.process.traversal import (
+    Bytecode, Traversal, TraversalStrategies, TraversalStrategy,
+)
+from gremlin_python.structure.graph import Graph
+
+log = logging.getLogger("gremlinpython")
+
+
+# ---------------------------------------------------------------------------
+# Public factory
+# ---------------------------------------------------------------------------
+
+def async_traversal():
+    """Experimental API. This API may have breaking changes or be removed in a 
subsequent minor release.
+
+    Return an _AsyncAnonymousTraversalSource.
+
+    Use in place of traversal() when working with AsyncDriverRemoteConnection.
+    """
+    return _AsyncAnonymousTraversalSource()
+
+
+class _AsyncAnonymousTraversalSource:
+    def with_remote(self, remote_connection):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Bind *remote_connection* and return an AsyncGraphTraversalSource.
+        """
+        return AsyncGraphTraversalSource(
+            Graph(),
+            AsyncTraversalStrategies(),
+            remote_connection=remote_connection,
+        )
+
+
+# ---------------------------------------------------------------------------
+# Strategy pipeline (async)
+# ---------------------------------------------------------------------------
+
+class AsyncTraversalStrategies(TraversalStrategies):
+    """Experimental API. This API may have breaking changes or be removed in a 
subsequent minor release.
+
+    Async-aware strategy pipeline.
+
+    Calls ``await strategy.apply(traversal)`` for coroutine strategies and
+    ``strategy.apply(traversal)`` for plain sync strategies so both can 
coexist.
+    """
+
+    async def apply_strategies(self, traversal):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release."""
+        for strategy in self.traversal_strategies:
+            if asyncio.iscoroutinefunction(strategy.apply):
+                await strategy.apply(traversal)
+            else:
+                strategy.apply(traversal)
+
+
+class AsyncRemoteStrategy(TraversalStrategy):
+    """Experimental API. This API may have breaking changes or be removed in a 
subsequent minor release.
+
+    Client-side strategy that submits bytecode to the remote server 
asynchronously.
+
+    Registered with the ``py:AsyncRemoteStrategy`` fqcn so it is never sent
+    to the server as part of the serialized traversal.
+    """
+
+    def __init__(self, remote_connection):
+        super().__init__(fqcn="py:AsyncRemoteStrategy")
+        self.remote_connection = remote_connection
+
+    async def apply(self, traversal):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release."""
+        if traversal.traversers is None:
+            remote_traversal = await 
self.remote_connection.submit(traversal.bytecode)
+            traversal.remote_results = remote_traversal
+            traversal.traversers = remote_traversal.traversers
+
+
+# ---------------------------------------------------------------------------
+# Traversal base (async terminal steps)
+# ---------------------------------------------------------------------------
+
+class AsyncTraversal(Traversal):
+    """Experimental API. This API may have breaking changes or be removed in a 
subsequent minor release.
+
+    Base traversal class that replaces blocking terminal steps with coroutines.
+
+    Concrete subclasses must be used with AsyncTraversalStrategies so that
+    apply_strategies() can be awaited inside __anext__().
+    """
+
+    # Prevent accidental sync iteration.
+    def __next__(self):
+        raise NotImplementedError(
+            "AsyncTraversal does not support synchronous iteration. "
+            "Use 'async for', 'await to_list()', or 'await next()'."
+        )
+
+    # ------------------------------------------------------------------
+    # Async iteration protocol
+    # ------------------------------------------------------------------
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        try:
+            if self.traversers is None:
+                await self.traversal_strategies.apply_strategies(self)
+            if self.last_traverser is None:
+                # StopAsyncIteration propagates naturally when the result set 
is exhausted.
+                self.last_traverser = await self.traversers.__anext__()
+            obj = self.last_traverser.object
+            self.last_traverser.bulk -= 1
+            if self.last_traverser.bulk <= 0:
+                self.last_traverser = None
+            return obj
+        except StopAsyncIteration:
+            raise
+        except BaseException:
+            self.traversers = None
+            self.last_traverser = None
+            raise
+
+    # ------------------------------------------------------------------
+    # Async terminal steps
+    # ------------------------------------------------------------------
+
+    async def to_list(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Execute the traversal and return all results as a list.
+        """
+        results = []
+        async for item in self:
+            results.append(item)
+        return results
+
+    async def to_set(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Execute the traversal and return all results as a set.
+        """
+        return set(await self.to_list())
+
+    async def next(self, amount=None):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Execute and return the first result, or the first *amount* results.
+
+        Raises StopAsyncIteration when *amount* is None and the result set is
+        empty.
+        """
+        if amount is None:
+            return await self.__anext__()
+        results = []
+        for _ in range(amount):
+            try:
+                results.append(await self.__anext__())
+            except StopAsyncIteration:
+                break
+        return results
+
+    async def iterate(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Execute the traversal, discarding all results.
+
+        Use for write operations (add_v, add_e, property, ...) where no return
+        value is needed.
+        """
+        if (
+            not self.bytecode.step_instructions
+            or self.bytecode.step_instructions[-1][0] != "discard"
+        ):
+            self.bytecode.add_step("discard")
+        while True:
+            try:
+                await self.next_traverser()
+            except StopAsyncIteration:
+                return self
+
+    async def has_next(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Return True if the traversal produces at least one result.
+        """
+        try:
+            if self.traversers is None:
+                await self.traversal_strategies.apply_strategies(self)
+            if self.last_traverser is None:
+                try:
+                    self.last_traverser = await self.traversers.__anext__()
+                except StopAsyncIteration:
+                    return False
+            return self.last_traverser is not None and 
self.last_traverser.bulk > 0
+        except BaseException:
+            self.traversers = None
+            self.last_traverser = None
+            raise
+
+    async def next_traverser(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Return the next raw Traverser.
+        """
+        try:
+            if self.traversers is None:
+                await self.traversal_strategies.apply_strategies(self)
+            if self.last_traverser is None:
+                return await self.traversers.__anext__()
+            temp = self.last_traverser
+            self.last_traverser = None
+            return temp
+        except StopAsyncIteration:
+            raise
+        except BaseException:
+            self.traversers = None
+            self.last_traverser = None
+            raise
+
+
+# ---------------------------------------------------------------------------
+# Concrete traversal classes
+# ---------------------------------------------------------------------------
+
+class AsyncGraphTraversal(GraphTraversal, AsyncTraversal):
+    """Experimental API. This API may have breaking changes or be removed in a 
subsequent minor release.
+
+    Async graph traversal.
+
+    Inherits all Gremlin DSL steps from GraphTraversal and async terminal
+    steps from AsyncTraversal via Python's MRO.
+
+    MRO: AsyncGraphTraversal -> GraphTraversal -> AsyncTraversal -> Traversal 
-> object
+
+    Because GraphTraversal does not define terminal steps directly (it
+    inherits them from Traversal), Python finds AsyncTraversal's async
+    versions first in the MRO before reaching Traversal's sync versions.
+    """
+
+    def clone(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release."""
+        return AsyncGraphTraversal(self.graph, self.traversal_strategies, 
copy.deepcopy(self.bytecode))
+
+
+class AsyncRemoteTraversal(AsyncTraversal):
+    """Experimental API. This API may have breaking changes or be removed in a 
subsequent minor release.
+
+    Holds the AsyncResultSet returned by AsyncDriverRemoteConnection.submit().
+
+    traversers is set directly to the result set; strategies are never
+    applied (there is nothing to apply on an already-executed traversal).
+    """
+
+    def __init__(self, traversers):
+        super().__init__(None, None, None)
+        self.traversers = traversers
+
+
+# ---------------------------------------------------------------------------
+# Traversal source
+# ---------------------------------------------------------------------------
+
+class AsyncGraphTraversalSource(GraphTraversalSource):
+    """Experimental API. This API may have breaking changes or be removed in a 
subsequent minor release.
+
+    Async traversal source.
+
+    All spawned traversals are AsyncGraphTraversal instances.
+    Configuration steps (with_bulk(), with_path(), ...) return a new
+    AsyncGraphTraversalSource.
+
+    Use async_traversal() to create one::
+
+        g = async_traversal().with_remote(rc)
+    """
+
+    def __init__(self, graph, traversal_strategies, bytecode=None, 
remote_connection=None):
+        # Call super WITHOUT remote_connection to avoid RemoteStrategy being 
added.
+        super().__init__(graph, traversal_strategies, bytecode)
+        self.graph_traversal = AsyncGraphTraversal
+        self.remote_connection = remote_connection
+        if remote_connection is not None:
+            
self.traversal_strategies.add_strategies([AsyncRemoteStrategy(remote_connection)])
+
+    def get_graph_traversal_source(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Return a copy of this source (used by configuration steps).
+        """
+        # Strategies are copied — do NOT pass remote_connection to avoid
+        # registering AsyncRemoteStrategy a second time.
+        return AsyncGraphTraversalSource(
+            self.graph,
+            AsyncTraversalStrategies(self.traversal_strategies),
+            Bytecode(self.bytecode),
+        )
+
+    def get_graph_traversal(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Return a fresh AsyncGraphTraversal for this source.
+        """
+        return AsyncGraphTraversal(
+            self.graph,
+            self.traversal_strategies,
+            Bytecode(self.bytecode),
+        )
+
+    async def tx(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Return an AsyncTransaction for this connection.
+
+        Raises if the connection is already session-bound.
+        """
+        strategy = next(
+            (s for s in self.traversal_strategies.traversal_strategies
+             if isinstance(s, AsyncRemoteStrategy)),
+            None,
+        )
+        if strategy is None:
+            raise Exception("No remote connection configured on this traversal 
source")
+        if strategy.remote_connection.is_session_bound():
+            raise Exception(
+                "Cannot open a transaction on an already session-bound 
connection"
+            )
+        return AsyncTransaction(self, strategy.remote_connection)
+
+
+# ---------------------------------------------------------------------------
+# Transaction
+# ---------------------------------------------------------------------------
+
+class AsyncTransaction:
+    """Experimental API. This API may have breaking changes or be removed in a 
subsequent minor release.
+
+    Async transaction over a session-bound connection.
+
+    Supports the async context-manager protocol::
+
+        async with await g.tx() as gtx:
+            await gtx.add_v("person").property("name", "pluto").iterate()
+            # commits on clean exit; rolls back on exception
+
+    Or manage it explicitly::
+
+        tx = await g.tx()
+        gtx = await tx.begin()
+        try:
+            await gtx.add_v("person").property("name", "pluto").iterate()
+            await tx.commit()
+        except Exception:
+            await tx.rollback()
+    """
+
+    def __init__(self, g, remote_connection):
+        self._g = g
+        self._remote_connection = remote_connection
+        self._session_connection = None
+        self._gtx = None
+        self._is_open = False
+        self._mutex = asyncio.Lock()
+
+    @property
+    def is_open(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release."""
+        if (
+            self._session_connection is not None
+            and self._session_connection.is_closed()
+        ) or self._remote_connection.is_closed():
+            self._is_open = False
+        return self._is_open
+
+    @property
+    def gtx(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release."""
+        if self._gtx is None:
+            raise Exception("Transaction not started — call begin() first")
+        return self._gtx
+
+    async def begin(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Open a session and return a session-bound AsyncGraphTraversalSource.
+        """
+        async with self._mutex:
+            if self.is_open:
+                raise Exception("Transaction is already open")
+            self._session_connection = self._remote_connection.create_session()
+            strategies = AsyncTraversalStrategies()
+            
strategies.add_strategies([AsyncRemoteStrategy(self._session_connection)])
+            self._gtx = AsyncGraphTraversalSource(
+                self._g.graph,
+                strategies,
+                self._g.bytecode,
+            )
+            self._is_open = True
+            return self._gtx
+
+    async def commit(self):
+        """Experimental API. This API may have breaking changes or be removed 
in a subsequent minor release.
+
+        Commit the transaction and close the session.
+        """
+        async with self._mutex:
+            if not self.is_open:
+                raise Exception("Transaction is not open")
+            await self._session_connection.commit()

Review Comment:
   Adjusted commit() and rollback() so session cleanup runs in a 
cancellation-safe finally block while preserving the original exception, and 
added unit tests for error and cancellation cases.





> Full async/await support in gremlin-python
> ------------------------------------------
>
>                 Key: TINKERPOP-2774
>                 URL: https://issues.apache.org/jira/browse/TINKERPOP-2774
>             Project: TinkerPop
>          Issue Type: Improvement
>          Components: python
>    Affects Versions: 3.5.3
>            Reporter: Ken Hu
>            Priority: Minor
>
> Recently, there have been multiple instances of users asking about issues 
> with event loops and aiohttp. This discussion nearly always ends up with the 
> user requesting for async/await support in gremlin-python. This means full 
> compatibility with asyncio and not needing to use threads.
> Async/await support is also a feature that those using newer, asynchronous 
> web frameworks are asking for as gremlin-python can be a performance 
> bottleneck due to its lack of support for async/await.
> My intention is that we can use this issue as a means of gauging the interest 
> from the community for this feature. If you are interested in having 
> gremlin-python support async/await then please leave a comment below.



--
This message was sent by Atlassian Jira
(v10.3.26#10030026)

Reply via email to