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)