async def execute_task(self, collector, **kwargs): called.append(1) async def cleanup1(): called.append("c1a") fut = hp.create_future() fut.set_result(True) await fut called.append("c1b") async def cleanup2(): called.append("c2a") fut = hp.create_future() fut.set_result(True) await fut called.append("c2b") collector.photons_app.cleaners.extend([cleanup1, cleanup2]) called.append(2) try: hp.get_event_loop().call_later(0.02, collector.photons_app.final_future.cancel) await asyncio.sleep(10) called.append("unexpected") except: fut = hp.create_future() fut.set_result(True) await fut called.append(3) raise finally: called.append(4)
def schedule_finisher(self, attr): """ Schedule maybe_finish to check in the future if we are done with this result """ current = getattr(self, attr) hp.get_event_loop().call_later(self.retry_gaps.finish_multi_gap, self.maybe_finish, current, attr)
async def find(self, sender, *, timeout, broadcast=True): """ calls ``await self.find_serials(sender, timeout=timeout, broadcast=broadcast)``, then determines the list of serials from the result and memoizes ``(found, serials)`` So that we only call it once regardless how many times find is called. The reset function is used to remove the cache """ if self.finding.done(): return await self.found self.finding.set_result(True) t = hp.get_event_loop().create_task( self.find_serials(sender, timeout=timeout, broadcast=broadcast)) def transfer(res): if res.cancelled(): self.found.cancel() return exc = res.exception() if exc: if not self.found.done(): self.found.set_exception(exc) return found = res.result() serials = [binascii.hexlify(key).decode() for key in found] if not self.found.done(): self.found.set_result((found, serials)) t.add_done_callback(transfer) return await self.found
async def set_cycle(self, event): duration = event.pkt.duration_s if duration == 0: duration = self.default_duration_s if self.enabled and not event.pkt.enable: await self.stop_cycle( event, stopped=LightLastHevCycleResult.INTERRUPTED_BY_LAN) changes = [ (("clean_details", "enabled"), bool(event.pkt.enable)), (("clean_details", "duration_s"), 0 if not event.pkt.enable else duration), ] if event.pkt.enable: changes.append((("clean_details", "last_result"), LightLastHevCycleResult.BUSY)) if self.last_trigger is not None: self.last_trigger.cancel() self.last_trigger = None self.triggered_at = time.time() self.last_trigger = hp.get_event_loop().call_later( duration, lambda: self.device.io["MEMORY"].ts.add( self.stop_cycle(event))) await self.device.change(*changes, event=event)
async def spawn_transport(self, timeout): sock = self.make_socket() fut, Protocol = self.make_socket_protocol() loop = hp.get_event_loop() def canceler(): if not fut.done(): fut.cancel() handle = loop.call_later(timeout, canceler) log.info(self.lc("Creating datagram endpoint", address=self.address)) await loop.create_datagram_endpoint(Protocol, sock=sock) try: return await fut finally: handle.cancel()
def finish(self): self.return_handle = hp.get_event_loop().call_later( 0.5, lambda: setattr(self, "returning", True))
def loop(): return hp.get_event_loop()
def ready(signum, frame): hp.get_event_loop().call_soon_threadsafe(fut.set_result, True)
def call_later(*args): return hp.get_event_loop().call_later(*args)
describe "with a pauser": async it "can be paused", FakeTime, MockedCallLater: called = [] pauser = asyncio.Semaphore() with FakeTime() as t: async with MockedCallLater(t) as m: async with hp.ATicker(5, min_wait=False, pauser=pauser) as ticks: async for i, nxt in ticks: called.append((i, nxt, time.time())) if len(called) == 2: await pauser.acquire() hp.get_event_loop().call_later(28, pauser.release) elif len(called) == 6: break assert called == [ (1, 5, 0), (2, 5.0, 5.0), (3, 2.0, 33.0), (4, 5.0, 35.0), (5, 5.0, 40.0), (6, 5.0, 45.0), ] assert m.called_times == [5.0, 10.0, 33.0, 33.0, 35.0, 40.0, 45.0] async it "cancelled final_future not stopped by pauser", FakeTime, MockedCallLater:
def stop_final_fut(): if not final_future.done(): hp.get_event_loop().call_soon_threadsafe( final_future.set_exception, ApplicationStopped())
from photons_transport.comms.receiver import Receiver from photons_app import helpers as hp from photons_messages import LIFXPacket from unittest import mock import binascii import asyncio import random import pytest describe "Receiver": async it "inits some variables": receiver = Receiver() assert receiver.loop is hp.get_event_loop() assert receiver.results == {} assert receiver.blank_target == b"\x00\x00\x00\x00\x00\x00\x00\x00" describe "Usage": @pytest.fixture() def V(self): class V: addr = mock.Mock(name="addr") source = random.randrange(0, 100) target = binascii.unhexlify("d073d50000000000") sequence = random.randrange(0, 100) receiver = Receiver() @hp.memoized_property
def stop(): if not graceful_future.done(): hp.get_event_loop().call_soon_threadsafe( graceful_future.set_exception, ApplicationStopped())
def stop(): hp.get_event_loop().call_soon_threadsafe(other_future.cancel)