forked from Rust-related/RustPython
Remove async sections of contextlib.py
This commit is contained in:
coolreader18
@@ -31,25 +31,26 @@ class AbstractContextManager(abc.ABC):
|
||||
return NotImplemented
|
||||
|
||||
|
||||
class AbstractAsyncContextManager(abc.ABC):
|
||||
# XXX
|
||||
# class AbstractAsyncContextManager(abc.ABC):
|
||||
|
||||
"""An abstract base class for asynchronous context managers."""
|
||||
# """An abstract base class for asynchronous context managers."""
|
||||
|
||||
async def __aenter__(self):
|
||||
"""Return `self` upon entering the runtime context."""
|
||||
return self
|
||||
# async def __aenter__(self):
|
||||
# """Return `self` upon entering the runtime context."""
|
||||
# return self
|
||||
|
||||
@abc.abstractmethod
|
||||
async def __aexit__(self, exc_type, exc_value, traceback):
|
||||
"""Raise any exception triggered within the runtime context."""
|
||||
return None
|
||||
# @abc.abstractmethod
|
||||
# async def __aexit__(self, exc_type, exc_value, traceback):
|
||||
# """Raise any exception triggered within the runtime context."""
|
||||
# return None
|
||||
|
||||
@classmethod
|
||||
def __subclasshook__(cls, C):
|
||||
if cls is AbstractAsyncContextManager:
|
||||
return _collections_abc._check_methods(C, "__aenter__",
|
||||
"__aexit__")
|
||||
return NotImplemented
|
||||
# @classmethod
|
||||
# def __subclasshook__(cls, C):
|
||||
# if cls is AbstractAsyncContextManager:
|
||||
# return _collections_abc._check_methods(C, "__aenter__",
|
||||
# "__aexit__")
|
||||
# return NotImplemented
|
||||
|
||||
|
||||
class ContextDecorator(object):
|
||||
@@ -161,50 +162,51 @@ class _GeneratorContextManager(_GeneratorContextManagerBase,
|
||||
raise RuntimeError("generator didn't stop after throw()")
|
||||
|
||||
|
||||
class _AsyncGeneratorContextManager(_GeneratorContextManagerBase,
|
||||
AbstractAsyncContextManager):
|
||||
"""Helper for @asynccontextmanager."""
|
||||
# XXX
|
||||
# class _AsyncGeneratorContextManager(_GeneratorContextManagerBase,
|
||||
# AbstractAsyncContextManager):
|
||||
# """Helper for @asynccontextmanager."""
|
||||
|
||||
async def __aenter__(self):
|
||||
try:
|
||||
return await self.gen.__anext__()
|
||||
except StopAsyncIteration:
|
||||
raise RuntimeError("generator didn't yield") from None
|
||||
# async def __aenter__(self):
|
||||
# try:
|
||||
# return await self.gen.__anext__()
|
||||
# except StopAsyncIteration:
|
||||
# raise RuntimeError("generator didn't yield") from None
|
||||
|
||||
async def __aexit__(self, typ, value, traceback):
|
||||
if typ is None:
|
||||
try:
|
||||
await self.gen.__anext__()
|
||||
except StopAsyncIteration:
|
||||
return
|
||||
else:
|
||||
raise RuntimeError("generator didn't stop")
|
||||
else:
|
||||
if value is None:
|
||||
value = typ()
|
||||
# See _GeneratorContextManager.__exit__ for comments on subtleties
|
||||
# in this implementation
|
||||
try:
|
||||
await self.gen.athrow(typ, value, traceback)
|
||||
raise RuntimeError("generator didn't stop after throw()")
|
||||
except StopAsyncIteration as exc:
|
||||
return exc is not value
|
||||
except RuntimeError as exc:
|
||||
if exc is value:
|
||||
return False
|
||||
# Avoid suppressing if a StopIteration exception
|
||||
# was passed to throw() and later wrapped into a RuntimeError
|
||||
# (see PEP 479 for sync generators; async generators also
|
||||
# have this behavior). But do this only if the exception wrapped
|
||||
# by the RuntimeError is actully Stop(Async)Iteration (see
|
||||
# issue29692).
|
||||
if isinstance(value, (StopIteration, StopAsyncIteration)):
|
||||
if exc.__cause__ is value:
|
||||
return False
|
||||
raise
|
||||
except BaseException as exc:
|
||||
if exc is not value:
|
||||
raise
|
||||
# async def __aexit__(self, typ, value, traceback):
|
||||
# if typ is None:
|
||||
# try:
|
||||
# await self.gen.__anext__()
|
||||
# except StopAsyncIteration:
|
||||
# return
|
||||
# else:
|
||||
# raise RuntimeError("generator didn't stop")
|
||||
# else:
|
||||
# if value is None:
|
||||
# value = typ()
|
||||
# # See _GeneratorContextManager.__exit__ for comments on subtleties
|
||||
# # in this implementation
|
||||
# try:
|
||||
# await self.gen.athrow(typ, value, traceback)
|
||||
# raise RuntimeError("generator didn't stop after throw()")
|
||||
# except StopAsyncIteration as exc:
|
||||
# return exc is not value
|
||||
# except RuntimeError as exc:
|
||||
# if exc is value:
|
||||
# return False
|
||||
# # Avoid suppressing if a StopIteration exception
|
||||
# # was passed to throw() and later wrapped into a RuntimeError
|
||||
# # (see PEP 479 for sync generators; async generators also
|
||||
# # have this behavior). But do this only if the exception wrapped
|
||||
# # by the RuntimeError is actully Stop(Async)Iteration (see
|
||||
# # issue29692).
|
||||
# if isinstance(value, (StopIteration, StopAsyncIteration)):
|
||||
# if exc.__cause__ is value:
|
||||
# return False
|
||||
# raise
|
||||
# except BaseException as exc:
|
||||
# if exc is not value:
|
||||
# raise
|
||||
|
||||
|
||||
def contextmanager(func):
|
||||
@@ -267,10 +269,12 @@ def asynccontextmanager(func):
|
||||
finally:
|
||||
<cleanup>
|
||||
"""
|
||||
@wraps(func)
|
||||
def helper(*args, **kwds):
|
||||
return _AsyncGeneratorContextManager(func, args, kwds)
|
||||
return helper
|
||||
# XXX
|
||||
# @wraps(func)
|
||||
# def helper(*args, **kwds):
|
||||
# return _AsyncGeneratorContextManager(func, args, kwds)
|
||||
# return helper
|
||||
raise RuntimeError("async not supported")
|
||||
|
||||
|
||||
class closing(AbstractContextManager):
|
||||
@@ -519,141 +523,142 @@ class ExitStack(_BaseExitStack, AbstractContextManager):
|
||||
self.__exit__(None, None, None)
|
||||
|
||||
|
||||
# Inspired by discussions on https://bugs.python.org/issue29302
|
||||
class AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager):
|
||||
"""Async context manager for dynamic management of a stack of exit
|
||||
callbacks.
|
||||
# XXX
|
||||
# # Inspired by discussions on https://bugs.python.org/issue29302
|
||||
# class AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager):
|
||||
# """Async context manager for dynamic management of a stack of exit
|
||||
# callbacks.
|
||||
|
||||
For example:
|
||||
async with AsyncExitStack() as stack:
|
||||
connections = [await stack.enter_async_context(get_connection())
|
||||
for i in range(5)]
|
||||
# All opened connections will automatically be released at the
|
||||
# end of the async with statement, even if attempts to open a
|
||||
# connection later in the list raise an exception.
|
||||
"""
|
||||
# For example:
|
||||
# async with AsyncExitStack() as stack:
|
||||
# connections = [await stack.enter_async_context(get_connection())
|
||||
# for i in range(5)]
|
||||
# # All opened connections will automatically be released at the
|
||||
# # end of the async with statement, even if attempts to open a
|
||||
# # connection later in the list raise an exception.
|
||||
# """
|
||||
|
||||
@staticmethod
|
||||
def _create_async_exit_wrapper(cm, cm_exit):
|
||||
async def _exit_wrapper(exc_type, exc, tb):
|
||||
return await cm_exit(cm, exc_type, exc, tb)
|
||||
return _exit_wrapper
|
||||
# @staticmethod
|
||||
# def _create_async_exit_wrapper(cm, cm_exit):
|
||||
# async def _exit_wrapper(exc_type, exc, tb):
|
||||
# return await cm_exit(cm, exc_type, exc, tb)
|
||||
# return _exit_wrapper
|
||||
|
||||
@staticmethod
|
||||
def _create_async_cb_wrapper(callback, *args, **kwds):
|
||||
async def _exit_wrapper(exc_type, exc, tb):
|
||||
await callback(*args, **kwds)
|
||||
return _exit_wrapper
|
||||
# @staticmethod
|
||||
# def _create_async_cb_wrapper(callback, *args, **kwds):
|
||||
# async def _exit_wrapper(exc_type, exc, tb):
|
||||
# await callback(*args, **kwds)
|
||||
# return _exit_wrapper
|
||||
|
||||
async def enter_async_context(self, cm):
|
||||
"""Enters the supplied async context manager.
|
||||
# async def enter_async_context(self, cm):
|
||||
# """Enters the supplied async context manager.
|
||||
|
||||
If successful, also pushes its __aexit__ method as a callback and
|
||||
returns the result of the __aenter__ method.
|
||||
"""
|
||||
_cm_type = type(cm)
|
||||
_exit = _cm_type.__aexit__
|
||||
result = await _cm_type.__aenter__(cm)
|
||||
self._push_async_cm_exit(cm, _exit)
|
||||
return result
|
||||
# If successful, also pushes its __aexit__ method as a callback and
|
||||
# returns the result of the __aenter__ method.
|
||||
# """
|
||||
# _cm_type = type(cm)
|
||||
# _exit = _cm_type.__aexit__
|
||||
# result = await _cm_type.__aenter__(cm)
|
||||
# self._push_async_cm_exit(cm, _exit)
|
||||
# return result
|
||||
|
||||
def push_async_exit(self, exit):
|
||||
"""Registers a coroutine function with the standard __aexit__ method
|
||||
signature.
|
||||
# def push_async_exit(self, exit):
|
||||
# """Registers a coroutine function with the standard __aexit__ method
|
||||
# signature.
|
||||
|
||||
Can suppress exceptions the same way __aexit__ method can.
|
||||
Also accepts any object with an __aexit__ method (registering a call
|
||||
to the method instead of the object itself).
|
||||
"""
|
||||
_cb_type = type(exit)
|
||||
try:
|
||||
exit_method = _cb_type.__aexit__
|
||||
except AttributeError:
|
||||
# Not an async context manager, so assume it's a coroutine function
|
||||
self._push_exit_callback(exit, False)
|
||||
else:
|
||||
self._push_async_cm_exit(exit, exit_method)
|
||||
return exit # Allow use as a decorator
|
||||
# Can suppress exceptions the same way __aexit__ method can.
|
||||
# Also accepts any object with an __aexit__ method (registering a call
|
||||
# to the method instead of the object itself).
|
||||
# """
|
||||
# _cb_type = type(exit)
|
||||
# try:
|
||||
# exit_method = _cb_type.__aexit__
|
||||
# except AttributeError:
|
||||
# # Not an async context manager, so assume it's a coroutine function
|
||||
# self._push_exit_callback(exit, False)
|
||||
# else:
|
||||
# self._push_async_cm_exit(exit, exit_method)
|
||||
# return exit # Allow use as a decorator
|
||||
|
||||
def push_async_callback(self, callback, *args, **kwds):
|
||||
"""Registers an arbitrary coroutine function and arguments.
|
||||
# def push_async_callback(self, callback, *args, **kwds):
|
||||
# """Registers an arbitrary coroutine function and arguments.
|
||||
|
||||
Cannot suppress exceptions.
|
||||
"""
|
||||
_exit_wrapper = self._create_async_cb_wrapper(callback, *args, **kwds)
|
||||
# Cannot suppress exceptions.
|
||||
# """
|
||||
# _exit_wrapper = self._create_async_cb_wrapper(callback, *args, **kwds)
|
||||
|
||||
# We changed the signature, so using @wraps is not appropriate, but
|
||||
# setting __wrapped__ may still help with introspection.
|
||||
_exit_wrapper.__wrapped__ = callback
|
||||
self._push_exit_callback(_exit_wrapper, False)
|
||||
return callback # Allow use as a decorator
|
||||
# # We changed the signature, so using @wraps is not appropriate, but
|
||||
# # setting __wrapped__ may still help with introspection.
|
||||
# _exit_wrapper.__wrapped__ = callback
|
||||
# self._push_exit_callback(_exit_wrapper, False)
|
||||
# return callback # Allow use as a decorator
|
||||
|
||||
async def aclose(self):
|
||||
"""Immediately unwind the context stack."""
|
||||
await self.__aexit__(None, None, None)
|
||||
# async def aclose(self):
|
||||
# """Immediately unwind the context stack."""
|
||||
# await self.__aexit__(None, None, None)
|
||||
|
||||
def _push_async_cm_exit(self, cm, cm_exit):
|
||||
"""Helper to correctly register coroutine function to __aexit__
|
||||
method."""
|
||||
_exit_wrapper = self._create_async_exit_wrapper(cm, cm_exit)
|
||||
_exit_wrapper.__self__ = cm
|
||||
self._push_exit_callback(_exit_wrapper, False)
|
||||
# def _push_async_cm_exit(self, cm, cm_exit):
|
||||
# """Helper to correctly register coroutine function to __aexit__
|
||||
# method."""
|
||||
# _exit_wrapper = self._create_async_exit_wrapper(cm, cm_exit)
|
||||
# _exit_wrapper.__self__ = cm
|
||||
# self._push_exit_callback(_exit_wrapper, False)
|
||||
|
||||
async def __aenter__(self):
|
||||
return self
|
||||
# async def __aenter__(self):
|
||||
# return self
|
||||
|
||||
async def __aexit__(self, *exc_details):
|
||||
received_exc = exc_details[0] is not None
|
||||
# async def __aexit__(self, *exc_details):
|
||||
# received_exc = exc_details[0] is not None
|
||||
|
||||
# We manipulate the exception state so it behaves as though
|
||||
# we were actually nesting multiple with statements
|
||||
frame_exc = sys.exc_info()[1]
|
||||
def _fix_exception_context(new_exc, old_exc):
|
||||
# Context may not be correct, so find the end of the chain
|
||||
while 1:
|
||||
exc_context = new_exc.__context__
|
||||
if exc_context is old_exc:
|
||||
# Context is already set correctly (see issue 20317)
|
||||
return
|
||||
if exc_context is None or exc_context is frame_exc:
|
||||
break
|
||||
new_exc = exc_context
|
||||
# Change the end of the chain to point to the exception
|
||||
# we expect it to reference
|
||||
new_exc.__context__ = old_exc
|
||||
# # We manipulate the exception state so it behaves as though
|
||||
# # we were actually nesting multiple with statements
|
||||
# frame_exc = sys.exc_info()[1]
|
||||
# def _fix_exception_context(new_exc, old_exc):
|
||||
# # Context may not be correct, so find the end of the chain
|
||||
# while 1:
|
||||
# exc_context = new_exc.__context__
|
||||
# if exc_context is old_exc:
|
||||
# # Context is already set correctly (see issue 20317)
|
||||
# return
|
||||
# if exc_context is None or exc_context is frame_exc:
|
||||
# break
|
||||
# new_exc = exc_context
|
||||
# # Change the end of the chain to point to the exception
|
||||
# # we expect it to reference
|
||||
# new_exc.__context__ = old_exc
|
||||
|
||||
# Callbacks are invoked in LIFO order to match the behaviour of
|
||||
# nested context managers
|
||||
suppressed_exc = False
|
||||
pending_raise = False
|
||||
while self._exit_callbacks:
|
||||
is_sync, cb = self._exit_callbacks.pop()
|
||||
try:
|
||||
if is_sync:
|
||||
cb_suppress = cb(*exc_details)
|
||||
else:
|
||||
cb_suppress = await cb(*exc_details)
|
||||
# # Callbacks are invoked in LIFO order to match the behaviour of
|
||||
# # nested context managers
|
||||
# suppressed_exc = False
|
||||
# pending_raise = False
|
||||
# while self._exit_callbacks:
|
||||
# is_sync, cb = self._exit_callbacks.pop()
|
||||
# try:
|
||||
# if is_sync:
|
||||
# cb_suppress = cb(*exc_details)
|
||||
# else:
|
||||
# cb_suppress = await cb(*exc_details)
|
||||
|
||||
if cb_suppress:
|
||||
suppressed_exc = True
|
||||
pending_raise = False
|
||||
exc_details = (None, None, None)
|
||||
except:
|
||||
new_exc_details = sys.exc_info()
|
||||
# simulate the stack of exceptions by setting the context
|
||||
_fix_exception_context(new_exc_details[1], exc_details[1])
|
||||
pending_raise = True
|
||||
exc_details = new_exc_details
|
||||
if pending_raise:
|
||||
try:
|
||||
# bare "raise exc_details[1]" replaces our carefully
|
||||
# set-up context
|
||||
fixed_ctx = exc_details[1].__context__
|
||||
raise exc_details[1]
|
||||
except BaseException:
|
||||
exc_details[1].__context__ = fixed_ctx
|
||||
raise
|
||||
return received_exc and suppressed_exc
|
||||
# if cb_suppress:
|
||||
# suppressed_exc = True
|
||||
# pending_raise = False
|
||||
# exc_details = (None, None, None)
|
||||
# except:
|
||||
# new_exc_details = sys.exc_info()
|
||||
# # simulate the stack of exceptions by setting the context
|
||||
# _fix_exception_context(new_exc_details[1], exc_details[1])
|
||||
# pending_raise = True
|
||||
# exc_details = new_exc_details
|
||||
# if pending_raise:
|
||||
# try:
|
||||
# # bare "raise exc_details[1]" replaces our carefully
|
||||
# # set-up context
|
||||
# fixed_ctx = exc_details[1].__context__
|
||||
# raise exc_details[1]
|
||||
# except BaseException:
|
||||
# exc_details[1].__context__ = fixed_ctx
|
||||
# raise
|
||||
# return received_exc and suppressed_exc
|
||||
|
||||
|
||||
class nullcontext(AbstractContextManager):
|
||||
|
||||
Reference in New Issue
Block a user