__all__ = ('Lock', 'Event', 'Condition', 'Semaphore', 'BoundedSemaphore')
import collections
-import warnings
-from . import events
from . import exceptions
+from . import mixins
class _ContextManagerMixin:
self.release()
-class Lock(_ContextManagerMixin):
+class Lock(_ContextManagerMixin, mixins._LoopBoundedMixin):
"""Primitive lock objects.
A primitive lock is a synchronization primitive that is not owned
"""
- def __init__(self, *, loop=None):
+ def __init__(self):
self._waiters = None
self._locked = False
- if loop is None:
- self._loop = events.get_event_loop()
- else:
- self._loop = loop
- warnings.warn("The loop argument is deprecated since Python 3.8, "
- "and scheduled for removal in Python 3.10.",
- DeprecationWarning, stacklevel=2)
def __repr__(self):
res = super().__repr__()
if self._waiters is None:
self._waiters = collections.deque()
- fut = self._loop.create_future()
+ fut = self._get_loop().create_future()
self._waiters.append(fut)
# Finally block should be called before the CancelledError
fut.set_result(True)
-class Event:
+class Event(mixins._LoopBoundedMixin):
"""Asynchronous equivalent to threading.Event.
Class implementing event objects. An event manages a flag that can be set
false.
"""
- def __init__(self, *, loop=None):
+ def __init__(self):
self._waiters = collections.deque()
self._value = False
- if loop is None:
- self._loop = events.get_event_loop()
- else:
- self._loop = loop
- warnings.warn("The loop argument is deprecated since Python 3.8, "
- "and scheduled for removal in Python 3.10.",
- DeprecationWarning, stacklevel=2)
def __repr__(self):
res = super().__repr__()
if self._value:
return True
- fut = self._loop.create_future()
+ fut = self._get_loop().create_future()
self._waiters.append(fut)
try:
await fut
self._waiters.remove(fut)
-class Condition(_ContextManagerMixin):
+class Condition(_ContextManagerMixin, mixins._LoopBoundedMixin):
"""Asynchronous equivalent to threading.Condition.
This class implements condition variable objects. A condition variable
A new Lock object is created and used as the underlying lock.
"""
- def __init__(self, lock=None, *, loop=None):
- if loop is None:
- self._loop = events.get_event_loop()
- else:
- self._loop = loop
- warnings.warn("The loop argument is deprecated since Python 3.8, "
- "and scheduled for removal in Python 3.10.",
- DeprecationWarning, stacklevel=2)
-
+ def __init__(self, lock=None):
if lock is None:
- lock = Lock(loop=loop)
- elif lock._loop is not self._loop:
+ lock = Lock()
+ elif lock._loop is not self._get_loop():
raise ValueError("loop argument must agree with lock")
self._lock = lock
self.release()
try:
- fut = self._loop.create_future()
+ fut = self._get_loop().create_future()
self._waiters.append(fut)
try:
await fut
self.notify(len(self._waiters))
-class Semaphore(_ContextManagerMixin):
+class Semaphore(_ContextManagerMixin, mixins._LoopBoundedMixin):
"""A Semaphore implementation.
A semaphore manages an internal counter which is decremented by each
ValueError is raised.
"""
- def __init__(self, value=1, *, loop=None):
+ def __init__(self, value=1):
if value < 0:
raise ValueError("Semaphore initial value must be >= 0")
self._value = value
self._waiters = collections.deque()
- if loop is None:
- self._loop = events.get_event_loop()
- else:
- self._loop = loop
- warnings.warn("The loop argument is deprecated since Python 3.8, "
- "and scheduled for removal in Python 3.10.",
- DeprecationWarning, stacklevel=2)
def __repr__(self):
res = super().__repr__()
True.
"""
while self._value <= 0:
- fut = self._loop.create_future()
+ fut = self._get_loop().create_future()
self._waiters.append(fut)
try:
await fut
above the initial value.
"""
- def __init__(self, value=1, *, loop=None):
- if loop:
- warnings.warn("The loop argument is deprecated since Python 3.8, "
- "and scheduled for removal in Python 3.10.",
- DeprecationWarning, stacklevel=2)
-
+ def __init__(self, value=1):
self._bound_value = value
- super().__init__(value, loop=loop)
+ super().__init__(value)
def release(self):
if self._value >= self._bound_value:
--- /dev/null
+"""Event loop mixins."""
+
+import threading
+from . import events
+
+_global_lock = threading.Lock()
+
+
+class _LoopBoundedMixin:
+ _loop = None
+
+ def _get_loop(self):
+ loop = events._get_running_loop()
+
+ if self._loop is None:
+ with _global_lock:
+ if self._loop is None:
+ self._loop = loop
+ if loop is not self._loop:
+ raise RuntimeError(f'{type(self).__name__} have already bounded to another loop')
+ return loop
import collections
import heapq
-import warnings
-from . import events
from . import locks
+from . import mixins
class QueueEmpty(Exception):
pass
-class Queue:
+class Queue(mixins._LoopBoundedMixin):
"""A queue, useful for coordinating producer and consumer coroutines.
If maxsize is less than or equal to zero, the queue size is infinite. If it
interrupted between calling qsize() and doing an operation on the Queue.
"""
- def __init__(self, maxsize=0, *, loop=None):
- if loop is None:
- self._loop = events.get_event_loop()
- else:
- self._loop = loop
- warnings.warn("The loop argument is deprecated since Python 3.8, "
- "and scheduled for removal in Python 3.10.",
- DeprecationWarning, stacklevel=2)
+ def __init__(self, maxsize=0):
self._maxsize = maxsize
# Futures.
# Futures.
self._putters = collections.deque()
self._unfinished_tasks = 0
- self._finished = locks.Event(loop=loop)
+ self._finished = locks.Event()
self._finished.set()
self._init(maxsize)
slot is available before adding item.
"""
while self.full():
- putter = self._loop.create_future()
+ putter = self._get_loop().create_future()
self._putters.append(putter)
try:
await putter
If queue is empty, wait until an item is available.
"""
while self.empty():
- getter = self._loop.create_future()
+ getter = self._get_loop().create_future()
self._getters.append(getter)
try:
await getter
raise TypeError(f"expect an iterable of futures, not {type(fs).__name__}")
from .queues import Queue # Import here to avoid circular import problem.
- done = Queue(loop=loop)
+ done = Queue()
if loop is None:
loop = events.get_event_loop()
self.disconnects = {fd: loop.create_future() for fd in range(3)}
self.data = {1: b'', 2: b''}
self.returncode = None
- self.got_data = {1: asyncio.Event(loop=loop),
- 2: asyncio.Event(loop=loop)}
+ self.got_data = {1: asyncio.Event(),
+ 2: asyncio.Event()}
def connection_made(self, transport):
self.transport = transport
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
- self.assertIsInstance(proto, MySubprocessProtocol)
- self.loop.run_until_complete(proto.connected)
- self.assertEqual('CONNECTED', proto.state)
- stdin = transp.get_pipe_transport(0)
- stdin.write(b'Python The Winner')
- self.loop.run_until_complete(proto.got_data[1].wait())
- with test_utils.disable_logger():
- transp.close()
- self.loop.run_until_complete(proto.completed)
- self.check_killed(proto.returncode)
- self.assertEqual(b'Python The Winner', proto.data[1])
+ transp, proto = self.loop.run_until_complete(connect)
+ self.assertIsInstance(proto, MySubprocessProtocol)
+ self.loop.run_until_complete(proto.connected)
+ self.assertEqual('CONNECTED', proto.state)
+
+ stdin = transp.get_pipe_transport(0)
+ stdin.write(b'Python The Winner')
+ self.loop.run_until_complete(proto.got_data[1].wait())
+ with test_utils.disable_logger():
+ transp.close()
+ self.loop.run_until_complete(proto.completed)
+ self.check_killed(proto.returncode)
+ self.assertEqual(b'Python The Winner', proto.data[1])
def test_subprocess_interactive(self):
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
- self.assertIsInstance(proto, MySubprocessProtocol)
- self.loop.run_until_complete(proto.connected)
- self.assertEqual('CONNECTED', proto.state)
+ transp, proto = self.loop.run_until_complete(connect)
+ self.assertIsInstance(proto, MySubprocessProtocol)
+ self.loop.run_until_complete(proto.connected)
+ self.assertEqual('CONNECTED', proto.state)
- stdin = transp.get_pipe_transport(0)
- stdin.write(b'Python ')
- self.loop.run_until_complete(proto.got_data[1].wait())
- proto.got_data[1].clear()
- self.assertEqual(b'Python ', proto.data[1])
+ stdin = transp.get_pipe_transport(0)
+ stdin.write(b'Python ')
+ self.loop.run_until_complete(proto.got_data[1].wait())
+ proto.got_data[1].clear()
+ self.assertEqual(b'Python ', proto.data[1])
- stdin.write(b'The Winner')
- self.loop.run_until_complete(proto.got_data[1].wait())
- self.assertEqual(b'Python The Winner', proto.data[1])
+ stdin.write(b'The Winner')
+ self.loop.run_until_complete(proto.got_data[1].wait())
+ self.assertEqual(b'Python The Winner', proto.data[1])
- with test_utils.disable_logger():
- transp.close()
- self.loop.run_until_complete(proto.completed)
- self.check_killed(proto.returncode)
+ with test_utils.disable_logger():
+ transp.close()
+ self.loop.run_until_complete(proto.completed)
+ self.check_killed(proto.returncode)
def test_subprocess_shell(self):
- with self.assertWarns(DeprecationWarning):
- connect = self.loop.subprocess_shell(
- functools.partial(MySubprocessProtocol, self.loop),
- 'echo Python')
- transp, proto = self.loop.run_until_complete(connect)
- self.assertIsInstance(proto, MySubprocessProtocol)
- self.loop.run_until_complete(proto.connected)
+ connect = self.loop.subprocess_shell(
+ functools.partial(MySubprocessProtocol, self.loop),
+ 'echo Python')
+ transp, proto = self.loop.run_until_complete(connect)
+ self.assertIsInstance(proto, MySubprocessProtocol)
+ self.loop.run_until_complete(proto.connected)
- transp.get_pipe_transport(0).close()
- self.loop.run_until_complete(proto.completed)
- self.assertEqual(0, proto.returncode)
- self.assertTrue(all(f.done() for f in proto.disconnects.values()))
- self.assertEqual(proto.data[1].rstrip(b'\r\n'), b'Python')
- self.assertEqual(proto.data[2], b'')
- transp.close()
+ transp.get_pipe_transport(0).close()
+ self.loop.run_until_complete(proto.completed)
+ self.assertEqual(0, proto.returncode)
+ self.assertTrue(all(f.done() for f in proto.disconnects.values()))
+ self.assertEqual(proto.data[1].rstrip(b'\r\n'), b'Python')
+ self.assertEqual(proto.data[2], b'')
+ transp.close()
def test_subprocess_exitcode(self):
connect = self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'exit 7', stdin=None, stdout=None, stderr=None)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
+ transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.completed)
self.assertEqual(7, proto.returncode)
connect = self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'exit 7', stdin=None, stdout=None, stderr=None)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
+
+ transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.assertIsNone(transp.get_pipe_transport(0))
self.assertIsNone(transp.get_pipe_transport(1))
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
- self.assertIsInstance(proto, MySubprocessProtocol)
- self.loop.run_until_complete(proto.connected)
+ transp, proto = self.loop.run_until_complete(connect)
+ self.assertIsInstance(proto, MySubprocessProtocol)
+ self.loop.run_until_complete(proto.connected)
- transp.kill()
- self.loop.run_until_complete(proto.completed)
- self.check_killed(proto.returncode)
- transp.close()
+ transp.kill()
+ self.loop.run_until_complete(proto.completed)
+ self.check_killed(proto.returncode)
+ transp.close()
def test_subprocess_terminate(self):
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
- self.assertIsInstance(proto, MySubprocessProtocol)
- self.loop.run_until_complete(proto.connected)
+ transp, proto = self.loop.run_until_complete(connect)
+ self.assertIsInstance(proto, MySubprocessProtocol)
+ self.loop.run_until_complete(proto.connected)
- transp.terminate()
- self.loop.run_until_complete(proto.completed)
- self.check_terminated(proto.returncode)
- transp.close()
+ transp.terminate()
+ self.loop.run_until_complete(proto.completed)
+ self.check_terminated(proto.returncode)
+ transp.close()
@unittest.skipIf(sys.platform == 'win32', "Don't have SIGHUP")
def test_subprocess_send_signal(self):
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
- self.assertIsInstance(proto, MySubprocessProtocol)
- self.loop.run_until_complete(proto.connected)
- transp.send_signal(signal.SIGHUP)
- self.loop.run_until_complete(proto.completed)
- self.assertEqual(-signal.SIGHUP, proto.returncode)
- transp.close()
+ transp, proto = self.loop.run_until_complete(connect)
+ self.assertIsInstance(proto, MySubprocessProtocol)
+ self.loop.run_until_complete(proto.connected)
+
+ transp.send_signal(signal.SIGHUP)
+ self.loop.run_until_complete(proto.completed)
+ self.assertEqual(-signal.SIGHUP, proto.returncode)
+ transp.close()
finally:
signal.signal(signal.SIGHUP, old_handler)
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
- self.assertIsInstance(proto, MySubprocessProtocol)
- self.loop.run_until_complete(proto.connected)
+ transp, proto = self.loop.run_until_complete(connect)
+ self.assertIsInstance(proto, MySubprocessProtocol)
+ self.loop.run_until_complete(proto.connected)
- stdin = transp.get_pipe_transport(0)
- stdin.write(b'test')
+ stdin = transp.get_pipe_transport(0)
+ stdin.write(b'test')
- self.loop.run_until_complete(proto.completed)
+ self.loop.run_until_complete(proto.completed)
- transp.close()
- self.assertEqual(b'OUT:test', proto.data[1])
- self.assertTrue(proto.data[2].startswith(b'ERR:test'), proto.data[2])
- self.assertEqual(0, proto.returncode)
+ transp.close()
+ self.assertEqual(b'OUT:test', proto.data[1])
+ self.assertTrue(proto.data[2].startswith(b'ERR:test'), proto.data[2])
+ self.assertEqual(0, proto.returncode)
def test_subprocess_stderr_redirect_to_stdout(self):
prog = os.path.join(os.path.dirname(__file__), 'echo2.py')
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog, stderr=subprocess.STDOUT)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
- self.assertIsInstance(proto, MySubprocessProtocol)
- self.loop.run_until_complete(proto.connected)
- stdin = transp.get_pipe_transport(0)
- self.assertIsNotNone(transp.get_pipe_transport(1))
- self.assertIsNone(transp.get_pipe_transport(2))
+ transp, proto = self.loop.run_until_complete(connect)
+ self.assertIsInstance(proto, MySubprocessProtocol)
+ self.loop.run_until_complete(proto.connected)
- stdin.write(b'test')
- self.loop.run_until_complete(proto.completed)
- self.assertTrue(proto.data[1].startswith(b'OUT:testERR:test'),
- proto.data[1])
- self.assertEqual(b'', proto.data[2])
+ stdin = transp.get_pipe_transport(0)
+ self.assertIsNotNone(transp.get_pipe_transport(1))
+ self.assertIsNone(transp.get_pipe_transport(2))
- transp.close()
- self.assertEqual(0, proto.returncode)
+ stdin.write(b'test')
+ self.loop.run_until_complete(proto.completed)
+ self.assertTrue(proto.data[1].startswith(b'OUT:testERR:test'),
+ proto.data[1])
+ self.assertEqual(b'', proto.data[2])
+
+ transp.close()
+ self.assertEqual(0, proto.returncode)
def test_subprocess_close_client_stream(self):
prog = os.path.join(os.path.dirname(__file__), 'echo3.py')
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
- with self.assertWarns(DeprecationWarning):
- transp, proto = self.loop.run_until_complete(connect)
- self.assertIsInstance(proto, MySubprocessProtocol)
- self.loop.run_until_complete(proto.connected)
- stdin = transp.get_pipe_transport(0)
- stdout = transp.get_pipe_transport(1)
- stdin.write(b'test')
- self.loop.run_until_complete(proto.got_data[1].wait())
- self.assertEqual(b'OUT:test', proto.data[1])
+ transp, proto = self.loop.run_until_complete(connect)
+ self.assertIsInstance(proto, MySubprocessProtocol)
+ self.loop.run_until_complete(proto.connected)
- stdout.close()
- self.loop.run_until_complete(proto.disconnects[1])
- stdin.write(b'xxx')
- self.loop.run_until_complete(proto.got_data[2].wait())
- if sys.platform != 'win32':
- self.assertEqual(b'ERR:BrokenPipeError', proto.data[2])
- else:
- # After closing the read-end of a pipe, writing to the
- # write-end using os.write() fails with errno==EINVAL and
- # GetLastError()==ERROR_INVALID_NAME on Windows!?! (Using
- # WriteFile() we get ERROR_BROKEN_PIPE as expected.)
- self.assertEqual(b'ERR:OSError', proto.data[2])
- with test_utils.disable_logger():
- transp.close()
- self.loop.run_until_complete(proto.completed)
- self.check_killed(proto.returncode)
+ stdin = transp.get_pipe_transport(0)
+ stdout = transp.get_pipe_transport(1)
+ stdin.write(b'test')
+ self.loop.run_until_complete(proto.got_data[1].wait())
+ self.assertEqual(b'OUT:test', proto.data[1])
+
+ stdout.close()
+ self.loop.run_until_complete(proto.disconnects[1])
+ stdin.write(b'xxx')
+ self.loop.run_until_complete(proto.got_data[2].wait())
+ if sys.platform != 'win32':
+ self.assertEqual(b'ERR:BrokenPipeError', proto.data[2])
+ else:
+ # After closing the read-end of a pipe, writing to the
+ # write-end using os.write() fails with errno==EINVAL and
+ # GetLastError()==ERROR_INVALID_NAME on Windows!?! (Using
+ # WriteFile() we get ERROR_BROKEN_PIPE as expected.)
+ self.assertEqual(b'ERR:OSError', proto.data[2])
+ with test_utils.disable_logger():
+ transp.close()
+ self.loop.run_until_complete(proto.completed)
+ self.check_killed(proto.returncode)
def test_subprocess_wait_no_same_group(self):
# start the new process in a new session
super().setUp()
self.loop = self.new_test_loop()
- def test_ctor_loop(self):
- loop = mock.Mock()
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=loop)
- self.assertIs(lock._loop, loop)
-
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
- self.assertIs(lock._loop, self.loop)
-
- def test_ctor_noloop(self):
- asyncio.set_event_loop(self.loop)
- lock = asyncio.Lock()
- self.assertIs(lock._loop, self.loop)
-
def test_repr(self):
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+ lock = asyncio.Lock()
self.assertTrue(repr(lock).endswith('[unlocked]>'))
self.assertTrue(RGX_REPR.match(repr(lock)))
self.assertTrue(RGX_REPR.match(repr(lock)))
def test_lock(self):
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+ lock = asyncio.Lock()
+ with self.assertWarns(DeprecationWarning):
@asyncio.coroutine
def acquire_lock():
return (yield from lock)
def test_lock_by_with_statement(self):
loop = asyncio.new_event_loop() # don't use TestLoop quirks
self.set_event_loop(loop)
- with self.assertWarns(DeprecationWarning):
- primitives = [
- asyncio.Lock(loop=loop),
- asyncio.Condition(loop=loop),
- asyncio.Semaphore(loop=loop),
- asyncio.BoundedSemaphore(loop=loop),
- ]
+ primitives = [
+ asyncio.Lock(),
+ asyncio.Condition(),
+ asyncio.Semaphore(),
+ asyncio.BoundedSemaphore(),
+ ]
+ with self.assertWarns(DeprecationWarning):
@asyncio.coroutine
def test(lock):
yield from asyncio.sleep(0.01)
self.assertFalse(primitive.locked())
def test_acquire(self):
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+ lock = asyncio.Lock()
result = []
self.assertTrue(self.loop.run_until_complete(lock.acquire()))
self.assertTrue(t3.result())
def test_acquire_cancel(self):
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+ lock = asyncio.Lock()
self.assertTrue(self.loop.run_until_complete(lock.acquire()))
task = self.loop.create_task(lock.acquire())
# B's waiter; instead, it should move on to C's waiter.
# Setup: A has the lock, b and c are waiting.
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+ lock = asyncio.Lock()
async def lockit(name, blocker):
await lock.acquire()
# Issue 32734
# Acquire 4 locks, cancel second, release first
# and 2 locks are taken at once.
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+ lock = asyncio.Lock()
lock_count = 0
call_count = 0
self.assertTrue(t3.cancelled())
def test_finished_waiter_cancelled(self):
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+ lock = asyncio.Lock()
ta = self.loop.create_task(lock.acquire())
test_utils.run_briefly(self.loop)
self.assertTrue(tb.cancelled())
def test_release_not_acquired(self):
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+ lock = asyncio.Lock()
self.assertRaises(RuntimeError, lock.release)
def test_release_no_waiters(self):
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+ lock = asyncio.Lock()
self.loop.run_until_complete(lock.acquire())
self.assertTrue(lock.locked())
super().setUp()
self.loop = self.new_test_loop()
- def test_ctor_loop(self):
- loop = mock.Mock()
- with self.assertWarns(DeprecationWarning):
- ev = asyncio.Event(loop=loop)
- self.assertIs(ev._loop, loop)
-
- with self.assertWarns(DeprecationWarning):
- ev = asyncio.Event(loop=self.loop)
- self.assertIs(ev._loop, self.loop)
-
- def test_ctor_noloop(self):
- asyncio.set_event_loop(self.loop)
- ev = asyncio.Event()
- self.assertIs(ev._loop, self.loop)
-
def test_repr(self):
- with self.assertWarns(DeprecationWarning):
- ev = asyncio.Event(loop=self.loop)
+ ev = asyncio.Event()
self.assertTrue(repr(ev).endswith('[unset]>'))
match = RGX_REPR.match(repr(ev))
self.assertEqual(match.group('extras'), 'unset')
self.assertTrue(RGX_REPR.match(repr(ev)))
def test_wait(self):
- with self.assertWarns(DeprecationWarning):
- ev = asyncio.Event(loop=self.loop)
+ ev = asyncio.Event()
self.assertFalse(ev.is_set())
result = []
self.assertIsNone(t3.result())
def test_wait_on_set(self):
- with self.assertWarns(DeprecationWarning):
- ev = asyncio.Event(loop=self.loop)
+ ev = asyncio.Event()
ev.set()
res = self.loop.run_until_complete(ev.wait())
self.assertTrue(res)
def test_wait_cancel(self):
- with self.assertWarns(DeprecationWarning):
- ev = asyncio.Event(loop=self.loop)
+ ev = asyncio.Event()
wait = self.loop.create_task(ev.wait())
self.loop.call_soon(wait.cancel)
self.assertFalse(ev._waiters)
def test_clear(self):
- with self.assertWarns(DeprecationWarning):
- ev = asyncio.Event(loop=self.loop)
+ ev = asyncio.Event()
self.assertFalse(ev.is_set())
ev.set()
self.assertFalse(ev.is_set())
def test_clear_with_waiters(self):
- with self.assertWarns(DeprecationWarning):
- ev = asyncio.Event(loop=self.loop)
+ ev = asyncio.Event()
result = []
async def c1(result):
super().setUp()
self.loop = self.new_test_loop()
- def test_ctor_loop(self):
- loop = mock.Mock()
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=loop)
- self.assertIs(cond._loop, loop)
-
- cond = asyncio.Condition(loop=self.loop)
- self.assertIs(cond._loop, self.loop)
-
- def test_ctor_noloop(self):
- asyncio.set_event_loop(self.loop)
- cond = asyncio.Condition()
- self.assertIs(cond._loop, self.loop)
-
def test_wait(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
result = []
async def c1(result):
self.assertTrue(t3.result())
def test_wait_cancel(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
self.loop.run_until_complete(cond.acquire())
wait = self.loop.create_task(cond.wait())
self.assertTrue(cond.locked())
def test_wait_cancel_contested(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
self.loop.run_until_complete(cond.acquire())
self.assertTrue(cond.locked())
def test_wait_cancel_after_notify(self):
# See bpo-32841
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
waited = False
+ cond = asyncio.Condition()
+ cond._loop = self.loop
+
async def wait_on_cond():
nonlocal waited
async with cond:
self.assertTrue(waited)
def test_wait_unacquired(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
self.assertRaises(
RuntimeError,
self.loop.run_until_complete, cond.wait())
def test_wait_for(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
presult = False
def predicate():
self.assertTrue(t.result())
def test_wait_for_unacquired(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
# predicate can return true immediately
res = self.loop.run_until_complete(cond.wait_for(lambda: [1, 2, 3]))
cond.wait_for(lambda: False))
def test_notify(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
result = []
async def c1(result):
self.assertTrue(t3.result())
def test_notify_all(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
result = []
self.assertTrue(t2.result())
def test_notify_unacquired(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
self.assertRaises(RuntimeError, cond.notify)
def test_notify_all_unacquired(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
self.assertRaises(RuntimeError, cond.notify_all)
def test_repr(self):
- with self.assertWarns(DeprecationWarning):
- cond = asyncio.Condition(loop=self.loop)
+ cond = asyncio.Condition()
self.assertTrue('unlocked' in repr(cond))
self.assertTrue(RGX_REPR.match(repr(cond)))
self.loop.run_until_complete(f())
def test_explicit_lock(self):
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
- cond = asyncio.Condition(lock, loop=self.loop)
+ lock = asyncio.Lock()
+ cond = asyncio.Condition(lock)
self.assertIs(cond._lock, lock)
self.assertIs(cond._loop, lock._loop)
def test_ambiguous_loops(self):
loop = self.new_test_loop()
self.addCleanup(loop.close)
- with self.assertWarns(DeprecationWarning):
- lock = asyncio.Lock(loop=self.loop)
+
+ lock = asyncio.Lock()
+ lock._loop = loop
+
+ async def _create_condition():
with self.assertRaises(ValueError):
- asyncio.Condition(lock, loop=loop)
+ asyncio.Condition(lock)
+
+ self.loop.run_until_complete(_create_condition())
def test_timeout_in_block(self):
loop = asyncio.new_event_loop()
self.addCleanup(loop.close)
async def task_timeout():
- condition = asyncio.Condition(loop=loop)
+ condition = asyncio.Condition()
async with condition:
with self.assertRaises(asyncio.TimeoutError):
await asyncio.wait_for(condition.wait(), timeout=0.5)
- with self.assertWarns(DeprecationWarning):
- loop.run_until_complete(task_timeout())
+ loop.run_until_complete(task_timeout())
class SemaphoreTests(test_utils.TestCase):
super().setUp()
self.loop = self.new_test_loop()
- def test_ctor_loop(self):
- loop = mock.Mock()
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(loop=loop)
- self.assertIs(sem._loop, loop)
-
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(loop=self.loop)
- self.assertIs(sem._loop, self.loop)
-
- def test_ctor_noloop(self):
- asyncio.set_event_loop(self.loop)
- sem = asyncio.Semaphore()
- self.assertIs(sem._loop, self.loop)
-
def test_initial_value_zero(self):
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(0, loop=self.loop)
+ sem = asyncio.Semaphore(0)
self.assertTrue(sem.locked())
def test_repr(self):
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(loop=self.loop)
+ sem = asyncio.Semaphore()
self.assertTrue(repr(sem).endswith('[unlocked, value:1]>'))
self.assertTrue(RGX_REPR.match(repr(sem)))
self.assertTrue(RGX_REPR.match(repr(sem)))
def test_semaphore(self):
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(loop=self.loop)
+ sem = asyncio.Semaphore()
self.assertEqual(1, sem._value)
with self.assertWarns(DeprecationWarning):
self.assertRaises(ValueError, asyncio.Semaphore, -1)
def test_acquire(self):
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(3, loop=self.loop)
+ sem = asyncio.Semaphore(3)
result = []
self.assertTrue(self.loop.run_until_complete(sem.acquire()))
self.loop.run_until_complete(asyncio.gather(*race_tasks))
def test_acquire_cancel(self):
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(loop=self.loop)
+ sem = asyncio.Semaphore()
self.loop.run_until_complete(sem.acquire())
acquire = self.loop.create_task(sem.acquire())
all(waiter.done() for waiter in sem._waiters))
def test_acquire_cancel_before_awoken(self):
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(value=0, loop=self.loop)
+ sem = asyncio.Semaphore(value=0)
t1 = self.loop.create_task(sem.acquire())
t2 = self.loop.create_task(sem.acquire())
test_utils.run_briefly(self.loop)
def test_acquire_hang(self):
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(value=0, loop=self.loop)
+ sem = asyncio.Semaphore(value=0)
t1 = self.loop.create_task(sem.acquire())
t2 = self.loop.create_task(sem.acquire())
self.assertTrue(sem.locked())
def test_release_not_acquired(self):
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.BoundedSemaphore(loop=self.loop)
+ sem = asyncio.BoundedSemaphore()
self.assertRaises(ValueError, sem.release)
def test_release_no_waiters(self):
- with self.assertWarns(DeprecationWarning):
- sem = asyncio.Semaphore(loop=self.loop)
+ sem = asyncio.Semaphore()
self.loop.run_until_complete(sem.acquire())
self.assertTrue(sem.locked())
class LockTests(BaseTest):
def test_context_manager_async_with(self):
- with self.assertWarns(DeprecationWarning):
- primitives = [
- asyncio.Lock(loop=self.loop),
- asyncio.Condition(loop=self.loop),
- asyncio.Semaphore(loop=self.loop),
- asyncio.BoundedSemaphore(loop=self.loop),
- ]
+ primitives = [
+ asyncio.Lock(),
+ asyncio.Condition(),
+ asyncio.Semaphore(),
+ asyncio.BoundedSemaphore(),
+ ]
async def test(lock):
await asyncio.sleep(0.01)
self.assertFalse(primitive.locked())
def test_context_manager_with_await(self):
- with self.assertWarns(DeprecationWarning):
- primitives = [
- asyncio.Lock(loop=self.loop),
- asyncio.Condition(loop=self.loop),
- asyncio.Semaphore(loop=self.loop),
- asyncio.BoundedSemaphore(loop=self.loop),
- ]
+ primitives = [
+ asyncio.Lock(),
+ asyncio.Condition(),
+ asyncio.Semaphore(),
+ asyncio.BoundedSemaphore(),
+ ]
async def test(lock):
await asyncio.sleep(0.01)
loop = self.new_test_loop(gen)
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=loop)
+ q = asyncio.Queue()
self.assertTrue(fn(q).startswith('<Queue'), fn(q))
id_is_present = hex(id(q)) in fn(q)
self.assertEqual(expect_id, id_is_present)
async def add_getter():
- q = asyncio.Queue(loop=loop)
+ q = asyncio.Queue()
# Start a task that waits to get.
loop.create_task(q.get())
# Let it start waiting.
# resume q.get coroutine to finish generator
q.put_nowait(0)
- with self.assertWarns(DeprecationWarning):
- loop.run_until_complete(add_getter())
+ loop.run_until_complete(add_getter())
async def add_putter():
- q = asyncio.Queue(maxsize=1, loop=loop)
+ q = asyncio.Queue(maxsize=1)
q.put_nowait(1)
# Start a task that waits to put.
loop.create_task(q.put(2))
# resume q.put coroutine to finish generator
q.get_nowait()
- with self.assertWarns(DeprecationWarning):
- loop.run_until_complete(add_putter())
- q = asyncio.Queue(loop=loop)
+ loop.run_until_complete(add_putter())
+ q = asyncio.Queue()
q.put_nowait(1)
self.assertTrue('_queue=[1]' in fn(q))
- def test_ctor_loop(self):
- loop = mock.Mock()
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=loop)
- self.assertIs(q._loop, loop)
-
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
- self.assertIs(q._loop, self.loop)
-
- def test_ctor_noloop(self):
- asyncio.set_event_loop(self.loop)
- q = asyncio.Queue()
- self.assertIs(q._loop, self.loop)
-
def test_repr(self):
self._test_repr_or_str(repr, True)
self._test_repr_or_str(str, False)
def test_empty(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
self.assertTrue(q.empty())
q.put_nowait(1)
self.assertFalse(q.empty())
self.assertTrue(q.empty())
def test_full(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
self.assertFalse(q.full())
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(maxsize=1, loop=self.loop)
+ q = asyncio.Queue(maxsize=1)
q.put_nowait(1)
self.assertTrue(q.full())
def test_order(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
for i in [1, 3, 2]:
q.put_nowait(i)
loop = self.new_test_loop(gen)
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(maxsize=2, loop=loop)
+ q = asyncio.Queue(maxsize=2)
self.assertEqual(2, q.maxsize)
have_been_put = []
class QueueGetTests(_QueueTestBase):
def test_blocking_get(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
q.put_nowait(1)
async def queue_get():
self.assertEqual(1, res)
def test_get_with_putters(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(1, loop=self.loop)
+ q = asyncio.Queue(1)
q.put_nowait(1)
waiter = self.loop.create_future()
loop = self.new_test_loop(gen)
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=loop)
- started = asyncio.Event(loop=loop)
+ q = asyncio.Queue()
+ started = asyncio.Event()
finished = False
async def queue_get():
self.assertAlmostEqual(0.01, loop.time())
def test_nonblocking_get(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
q.put_nowait(1)
self.assertEqual(1, q.get_nowait())
def test_nonblocking_get_exception(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
self.assertRaises(asyncio.QueueEmpty, q.get_nowait)
def test_get_cancelled(self):
loop = self.new_test_loop(gen)
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=loop)
+ q = asyncio.Queue()
async def queue_get():
return await asyncio.wait_for(q.get(), 0.051)
self.assertAlmostEqual(0.06, loop.time())
def test_get_cancelled_race(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
t1 = self.loop.create_task(q.get())
t2 = self.loop.create_task(q.get())
self.assertEqual(t2.result(), 'a')
def test_get_with_waiting_putters(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop, maxsize=1)
+ q = asyncio.Queue(maxsize=1)
self.loop.create_task(q.put('a'))
self.loop.create_task(q.put('b'))
test_utils.run_briefly(self.loop)
queue_size = 1
producer_num_items = 5
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(queue_size, loop=self.loop)
+ async def create_queue():
+ queue = asyncio.Queue(queue_size)
+ queue._get_loop()
+ return queue
+
+ q = self.loop.run_until_complete(create_queue())
self.loop.run_until_complete(
asyncio.gather(producer(q, producer_num_items),
except asyncio.TimeoutError:
pass
- with self.assertWarns(DeprecationWarning):
- queue = asyncio.Queue(loop=self.loop, maxsize=5)
+ queue = asyncio.Queue(maxsize=5)
self.loop.run_until_complete(self.loop.create_task(consumer(queue)))
self.assertEqual(len(queue._getters), 0)
class QueuePutTests(_QueueTestBase):
def test_blocking_put(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
async def queue_put():
# No maxsize, won't block.
loop = self.new_test_loop(gen)
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(maxsize=1, loop=loop)
- started = asyncio.Event(loop=loop)
+ q = asyncio.Queue(maxsize=1)
+ started = asyncio.Event()
finished = False
async def queue_put():
self.assertAlmostEqual(0.01, loop.time())
def test_nonblocking_put(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
q.put_nowait(1)
self.assertEqual(1, q.get_nowait())
loop = self.new_test_loop(gen)
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=loop)
+ q = asyncio.Queue()
reader = loop.create_task(q.get())
loop = self.new_test_loop(gen)
loop.set_debug(True)
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=loop)
+ q = asyncio.Queue()
reader1 = loop.create_task(q.get())
reader2 = loop.create_task(q.get())
loop = self.new_test_loop(gen)
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(1, loop=loop)
+ q = asyncio.Queue(1)
q.put_nowait(1)
self.assertEqual(q.qsize(), 0)
def test_nonblocking_put_exception(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(maxsize=1, loop=self.loop)
+ q = asyncio.Queue(maxsize=1, )
q.put_nowait(1)
self.assertRaises(asyncio.QueueFull, q.put_nowait, 2)
def test_float_maxsize(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(maxsize=1.3, loop=self.loop)
+ q = asyncio.Queue(maxsize=1.3, )
q.put_nowait(1)
q.put_nowait(2)
self.assertTrue(q.full())
self.assertRaises(asyncio.QueueFull, q.put_nowait, 3)
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(maxsize=1.3, loop=self.loop)
+ q = asyncio.Queue(maxsize=1.3, )
async def queue_put():
await q.put(1)
self.loop.run_until_complete(queue_put())
def test_put_cancelled(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
async def queue_put():
await q.put(1)
self.assertTrue(t.result())
def test_put_cancelled_race(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop, maxsize=1)
+ q = asyncio.Queue(maxsize=1)
put_a = self.loop.create_task(q.put('a'))
put_b = self.loop.create_task(q.put('b'))
self.loop.run_until_complete(put_b)
def test_put_with_waiting_getters(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.Queue(loop=self.loop)
+ q = asyncio.Queue()
t = self.loop.create_task(q.get())
test_utils.run_briefly(self.loop)
self.loop.run_until_complete(q.put('a'))
def test_why_are_putters_waiting(self):
# From issue #265.
- with self.assertWarns(DeprecationWarning):
- queue = asyncio.Queue(2, loop=self.loop)
+ async def create_queue():
+ q = asyncio.Queue(2)
+ q._get_loop()
+ return q
+
+ queue = self.loop.run_until_complete(create_queue())
async def putter(item):
await queue.put(item)
loop = self.new_test_loop(a_generator)
# Full queue.
- with self.assertWarns(DeprecationWarning):
- queue = asyncio.Queue(loop=loop, maxsize=1)
+ queue = asyncio.Queue(maxsize=1)
queue.put_nowait(1)
# Task waiting for space to put an item in the queue.
loop = self.new_test_loop(gen)
# Full Queue.
- with self.assertWarns(DeprecationWarning):
- queue = asyncio.Queue(1, loop=loop)
+ queue = asyncio.Queue(1)
queue.put_nowait(1)
# Task waiting for space to put a item in the queue.
class LifoQueueTests(_QueueTestBase):
def test_order(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.LifoQueue(loop=self.loop)
+ q = asyncio.LifoQueue()
for i in [1, 3, 2]:
q.put_nowait(i)
class PriorityQueueTests(_QueueTestBase):
def test_order(self):
- with self.assertWarns(DeprecationWarning):
- q = asyncio.PriorityQueue(loop=self.loop)
+ q = asyncio.PriorityQueue()
for i in [1, 3, 2]:
q.put_nowait(i)
q_class = None
def test_task_done_underflow(self):
- with self.assertWarns(DeprecationWarning):
- q = self.q_class(loop=self.loop)
+ q = self.q_class()
self.assertRaises(ValueError, q.task_done)
def test_task_done(self):
- with self.assertWarns(DeprecationWarning):
- q = self.q_class(loop=self.loop)
+ q = self.q_class()
for i in range(100):
q.put_nowait(i)
self.loop.run_until_complete(asyncio.wait(tasks))
def test_join_empty_queue(self):
- with self.assertWarns(DeprecationWarning):
- q = self.q_class(loop=self.loop)
+ q = self.q_class()
# Test that a queue join()s successfully, and before anything else
# (done twice for insurance).
self.loop.run_until_complete(join())
def test_format(self):
- with self.assertWarns(DeprecationWarning):
- q = self.q_class(loop=self.loop)
+ q = self.q_class()
self.assertEqual(q._format(), 'maxsize=0')
q._unfinished_tasks = 2
def setUp(self):
self._get_running_loop = events._get_running_loop
- events._get_running_loop = lambda: None
+
+ def _get_running_loop():
+ frame = sys._getframe(1)
+
+ if frame.f_globals['__name__'] == 'asyncio.mixins':
+ # When we called from LoopBoundedMixin we should
+ # fallback to default implementation of get_running_loop
+ try:
+ return events.get_running_loop()
+ except RuntimeError:
+ return None
+
+ return None
+
+ events._get_running_loop = _get_running_loop
self._thread_cleanup = threading_helper.threading_setup()
def tearDown(self):
--- /dev/null
+Remove loop parameter from ``__init__`` in all ``asyncio.locks`` and
+``asyncio.Queue`` classes. Patch provided by Yurii Karabas.
projects / thirdparty / Python / cpython.git / commitdiff
