pep-484: asyncio

in this patch the asyncio/events.py module, which
existed only to raise errors when trying to attach event
listeners, is removed, as we were already coding an asyncio-specific
workaround in upstream Pool / Session to raise this error,
just moved the error out to the target and did the same thing
for Engine.

We also add an async_sessionmaker class.  The initial rationale
here is because sessionmaker() is hardcoded to Session subclasses,
and there's not a way to get the use case of
sessionmaker(class_=AsyncSession) to type correctly without changing
the sessionmaker() symbol itself to be a function and not a class,
which gets too complicated for what this is. Additionally,
_SessionClassMethods has only three methods on it, one of which
is not usable with asyncio (close_all()), the others
not generally used from the session class.

Change-Id: I064a5fa5d91cc8d5bbe9597437536e37b4e801fe

1 files changed, 6 insertions, 4 deletions

diff --git a/lib/sqlalchemy/util/_concurrency_py3k.py b/lib/sqlalchemy/util/_concurrency_py3k.py
index 28b062d3d..6ad099eef 100644
--- a/lib/sqlalchemy/util/_concurrency_py3k.py
+++ b/lib/sqlalchemy/util/_concurrency_py3k.py
@@ -4,6 +4,7 @@
 #
 # This module is part of SQLAlchemy and is released under
 # the MIT License: https://www.opensource.org/licenses/mit-license.php
+from __future__ import annotations
 
 import asyncio
 from contextvars import copy_context as _copy_context
@@ -19,6 +20,8 @@ from .langhelpers import memoized_property
 from .. import exc
 from ..util.typing import Protocol
 
+_T = TypeVar("_T", bound=Any)
+
 if typing.TYPE_CHECKING:
 
     class greenlet(Protocol):
@@ -52,8 +55,6 @@ if not typing.TYPE_CHECKING:
     except (ImportError, AttributeError):
         _copy_context = None  # noqa
 
-_T = TypeVar("_T", bound=Any)
-
 
 def is_exit_exception(e: BaseException) -> bool:
     # note asyncio.CancelledError is already BaseException
@@ -128,11 +129,11 @@ def await_fallback(awaitable: Awaitable[_T]) -> _T:
 
 
 async def greenlet_spawn(
-    fn: Callable[..., Any],
+    fn: Callable[..., _T],
     *args: Any,
     _require_await: bool = False,
     **kwargs: Any,
-) -> Any:
+) -> _T:
     """Runs a sync function ``fn`` in a new greenlet.
 
     The sync function can then use :func:`await_` to wait for async
@@ -143,6 +144,7 @@ async def greenlet_spawn(
     :param \\*\\*kwargs: Keyword arguments to pass to the ``fn`` callable.
     """
 
+    result: _T
     context = _AsyncIoGreenlet(fn, getcurrent())
     # runs the function synchronously in gl greenlet. If the execution
     # is interrupted by await_, context is not dead and result is a