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)
