def test__run_once_logging(self, m_logger, m_time):
# Log to INFO level if timeout > 1.0 sec.
idx = -1
data = [10.0, 10.0, 12.0, 13.0]
def monotonic():
nonlocal data, idx
idx += 1
return data[idx]
m_time.monotonic = monotonic
self.loop._scheduled.append(
asyncio.TimerHandle(11.0, lambda: True, (), self.loop))
self.loop._process_events = mock.Mock()
self.loop._run_once()
self.assertEqual(logging.INFO, m_logger.log.call_args[0][0])
idx = -1
data = [10.0, 10.0, 10.3, 13.0]
self.loop._scheduled = [
asyncio.TimerHandle(11.0, lambda: True, (), self.loop)
]
self.loop._run_once()
self.assertEqual(logging.DEBUG, m_logger.log.call_args[0][0])
def call_at(self, when, callback, *args, **context):
"""asyncio's time-based delay
Note that the callback is a sync function.
"""
self._check_callback(callback, 'call_at')
return self._queue_handle(asyncio.TimerHandle(when, callback, args, self, **context))
def call_at(self, when, callback, *args):
if when < self._time:
raise Exception("Can't schedule in the past")
h = asyncio.TimerHandle(when, callback, args, self)
heapq.heappush(self._scheduled, h)
h._scheduled = True
return h
def test__run_once(self):
h1 = asyncio.TimerHandle(time.monotonic() + 5.0, lambda: True, (),
self.loop)
h2 = asyncio.TimerHandle(time.monotonic() + 10.0, lambda: True, (),
self.loop)
h1.cancel()
self.loop._process_events = mock.Mock()
self.loop._scheduled.append(h1)
self.loop._scheduled.append(h2)
self.loop._run_once()
t = self.loop._selector.select.call_args[0][0]
self.assertTrue(9.5 < t < 10.5, t)
self.assertEqual([h2], self.loop._scheduled)
self.assertTrue(self.loop._process_events.called)
def test_run_once_in_executor_handle(self):
def cb():
pass
self.assertRaises(AssertionError, self.loop.run_in_executor, None,
asyncio.Handle(cb, (), self.loop), ('', ))
self.assertRaises(AssertionError, self.loop.run_in_executor, None,
asyncio.TimerHandle(10, cb, (), self.loop))
def call_at(self, when: float, callback: Callable, *args: Any,
**kwargs: Any) -> asyncio.TimerHandle:
th = asyncio.TimerHandle(when,
callback,
list(args),
loop=self,
**kwargs)
heapq.heappush(self._tasks, th)
return th
def call_later(self, delay, callback, *args, **context):
"""asyncio's timer-based delay
Note that the callback is a sync function.
:param delay: Time to wait, in seconds.
:param callback: Sync function to call.
:return: a handle which may be used to cancel the timer.
"""
self._check_callback(callback, 'call_later')
assert delay >= 0, delay
h = asyncio.TimerHandle(delay + self.time(), callback, args, self, **context)
self._queue_handle(h)
return h
def test__run_once_schedule_handle(self):
handle = None
processed = False
def cb(loop):
nonlocal processed, handle
processed = True
handle = loop.call_soon(lambda: True)
h = asyncio.TimerHandle(time.monotonic() - 1, cb, (self.loop, ),
self.loop)
self.loop._process_events = mock.Mock()
self.loop._scheduled.append(h)
self.loop._run_once()
self.assertTrue(processed)
self.assertEqual([handle], list(self.loop._ready))
def call_at(self, when, callback, *args, context=None):
cfwhen = posix2cftime(when)
if self._timer is None:
self._timer = CFRunLoopTimerCreateWithHandler(
None, cfwhen, 1000.0, 0, 0,
lambda timer: self._process_timer())
CFRunLoopAddTimer(self._loop, self._timer, kCFRunLoopCommonModes)
handle = asyncio.TimerHandle(when,
callback,
args,
self,
context=context)
heapq.heappush(self._timer_q, handle)
if CFRunLoopTimerGetNextFireDate(self._timer) > posix2cftime(
self._timer_q[0].when()):
CFRunLoopTimerSetNextFireDate(
self._timer, posix2cftime(self._timer_q[0].when()))
return handle
def test__add_callback_timer(self):
h = asyncio.TimerHandle(time.monotonic() + 10, lambda: False, (),
self.loop)
self.loop._add_callback(h)
self.assertIn(h, self.loop._scheduled)
def create_callback(when, callback, args, loop, context):
return asyncio.TimerHandle(when, callback, args, loop, context=context)
def create_callback(when, callback, args, loop, _):
return asyncio.TimerHandle(when, callback, args, loop)
def call_at(self, when, callback, *args):
handler = asyncio.TimerHandle(when, callback, args, self)
self._scheduled.append(handler)
return handler
def call_at(self, when:float, callback:Callable[...,Any], *args:Any, context:Optional[Context]=None) -> asyncio.TimerHandle:
th = asyncio.TimerHandle(when, callback, list(args), self, context) # type:ignore
heapq.heappush(self._tasks, th)
return th
