def _add_writer(self, fd, callback, *args):
if sys.version_info >= (3, 7):
self.writers[fd] = events.Handle(callback,
args,
self,
context=None)
else:
self.writers[fd] = events.Handle(callback, args, self)
def test__add_callback_cancelled_handle(self):
h = events.Handle(lambda: False, ())
h.cancel()
self.loop._add_callback(h)
self.assertFalse(self.loop._scheduled)
self.assertFalse(self.loop._ready)
def my_run_once(self):
if self._idle:
self._ready.append(events.Handle(lambda: None, (), self))
real_run_once(self)
if self._idle:
handle = self._idle.popleft()
handle._run()
def call_at(self, when, callback, *args, context=None):
handle = events.Handle(callback, args, self, context)
# Twisted timers are relatives, contrary to asyncio.
delay = when - self.time()
delay = max(delay, 0)
self._reactor.callLater(delay, handle._run)
return handle
def test_run_once_in_executor_handle(self):
def cb():
pass
self.assertRaises(AssertionError, self.loop.run_in_executor, None,
events.Handle(cb, ()), ('', ))
self.assertRaises(AssertionError, self.loop.run_in_executor, None,
events.TimerHandle(10, cb, ()))
def test_run_once_in_executor_cancelled(self):
def cb():
pass
h = events.Handle(cb, ())
h.cancel()
f = self.loop.run_in_executor(None, h)
self.assertIsInstance(f, futures.Future)
self.assertTrue(f.done())
self.assertIsNone(f.result())
def _add_writer(self, fd, callback, *args):
self._check_closed()
handle = events.Handle(callback, args, self)
try:
key = self._selector.get_key(fd)
except KeyError:
self._selector.register(fd, selectors.EVENT_WRITE, (None, handle))
else:
mask, (reader, writer) = key.events, key.data
self._selector.modify(fd, mask | selectors.EVENT_WRITE,
(reader, handle))
if writer is not None:
writer.cancel()
def add_reader(self, fd, callback, *args):
"""Add a reader callback."""
self._check_closed()
handle = events.Handle(callback, args, self)
try:
key = self._selector.get_key(fd)
except KeyError:
self._selector.register(fd, selectors.EVENT_READ, (handle, None))
else:
mask, (reader, writer) = key.events, key.data
self._selector.modify(fd, mask | selectors.EVENT_READ,
(handle, writer))
if reader is not None:
reader.cancel()
def BaseSelectorEventLoop_add_reader(self, fd, callback, *args):
"""Add a reader callback."""
if self._selector is None:
raise RuntimeError('Event loop is closed')
handle = events.Handle(callback, args, self)
try:
key = self._selector.get_key(fd)
except KeyError:
self._selector.register(fd, selectors.EVENT_READ, (handle, None, None))
else:
mask, (reader, writer, excepter) = key.events, key.data
self._selector.modify(fd, mask | selectors.EVENT_READ,
(handle, writer, excepter))
if reader is not None:
reader.cancel()
def _call_soon(self, callback, args):
# find the partition by following the next strategies
# 1 - The callback is a method realated to a task
# 2 - If not, usual strategy
try:
if isinstance(callback.__self__, Task):
partition = callback.__self__.partition
else:
partition = _find_partition(self)
except AttributeError:
partition = _find_partition(self)
handle = events.Handle(callback, args, self)
if handle._source_traceback:
del handle._source_traceback[-1]
self._partitions[partition].handles.append(handle)
return handle
def test_run_once_in_executor_plain(self):
def cb():
pass
h = events.Handle(cb, ())
f = futures.Future(loop=self.loop)
executor = unittest.mock.Mock()
executor.submit.return_value = f
self.loop.set_default_executor(executor)
res = self.loop.run_in_executor(None, h)
self.assertIs(f, res)
executor = unittest.mock.Mock()
executor.submit.return_value = f
res = self.loop.run_in_executor(executor, h)
self.assertIs(f, res)
self.assertTrue(executor.submit.called)
f.cancel() # Don't complain about abandoned Future.
def _add_writer(self, fd, callback, *args):
self.writers[fd] = events.Handle(callback, args, self, None)
def call_soon(self, callback, *args, context=None):
handle = events.Handle(callback, args, self, context)
self._reactor.callLater(0, handle._run)
return handle
def idle_call(self, callback):
if asyncio.iscoroutinefunction(callback):
raise TypeError("coroutines cannot be used with idle_call()")
handle = events.Handle(callback, [], self)
self._idle.append(handle)
def call_soon_threadsafe(self, callback, *args, context=None):
handle = events.Handle(callback, args, self, context)
self._reactor.callFromThread(handle._run)
return handle
def test__add_callback_handle(self):
h = events.Handle(lambda: False, ())
self.loop._add_callback(h)
self.assertFalse(self.loop._scheduled)
self.assertIn(h, self.loop._ready)
def make_handle(callback, args, loop, context):
return events.Handle(callback, args, loop, context)
def call_soon(self, callback, *args):
h = events.Handle(callback, args, self)
self._ready.append(h)
if not self._will_dispatch:
self._schedule_dispatch()
return h
def _add_reader(self, fd, callback, *args):
self.readers[fd] = events.Handle(callback, args, self)
def make_handle(callback, args, loop, context):
# python 3.6 does not support async contextvars
return events.Handle(callback, args, loop)
