async def execute(self):
afr = await self.finder.args_for_run()
fltr = chp.filter_from_matcher(self.matcher)
if self.refresh is not None:
fltr.force_refresh = self.refresh
found_serials = await self.finder.serials(filtr=fltr)
fltr = chp.filter_from_matcher({
"serial": found_serials,
"cap": "chain"
})
try:
serials = await self.finder.serials(filtr=fltr)
except FoundNoDevices:
raise FoundNoTiles(matcher=self.matcher)
find_fltr = chp.clone_filter(fltr, force_refresh=False)
reference = self.finder.find(filtr=find_fltr)
animation_id = self.animations.start(
self.animation,
self.target,
serials,
reference,
afr,
self.options,
stop_conflicting=self.stop_conflicting,
)
return {"animation_id": animation_id}
async def execute(self):
fltr = chp.filter_from_matcher(self.matcher)
if self.refresh is not None:
fltr.force_refresh = self.refresh
gatherer = Gatherer(self.target)
theme_msg = self.theme_msg(gatherer)
async def gen(reference, afr, **kwargs):
if self.apply_theme:
yield theme_msg
if self.matrix_animation:
yield SetTileEffect(self.matrix_animation,
gatherer=gatherer,
**self.matrix_options)
if self.linear_animation:
yield SetZonesEffect(self.linear_animation,
gatherer=gatherer,
**self.linear_options)
script = self.target.script(FromGeneratorPerSerial(gen))
return await chp.run(
script,
fltr,
self.finder,
message_timeout=self.timeout,
add_replies=False,
)
async def execute(self):
fltr = chp.filter_from_matcher(self.matcher)
if self.refresh is not None:
fltr.force_refresh = self.refresh
gatherer = Gatherer(self.target)
plans = make_plans("firmware_effects", "capability")
afr = await self.finder.args_for_run()
serials = await self.finder.serials(filtr=fltr)
result = chp.ResultBuilder()
result.add_serials(serials)
async for serial, _, info in gatherer.gather_per_serial(
plans,
serials,
afr,
error_catcher=result.error,
message_timeout=self.timeout,
):
r = {}
if "capability" in info:
r["product"] = info["capability"]["product"]
if "firmware_effects" in info:
r["effect"] = info["firmware_effects"]
result.result["results"][serial] = self.convert_enums(r)
return result
async def execute(self):
fltr = chp.filter_from_matcher(self.matcher, self.refresh)
msg = Transformer.using(self.transform, **self.transform_options)
script = self.target.script(msg)
return await chp.run(
script, fltr, self.finder, add_replies=False, message_timeout=self.timeout
)
async def execute(self):
fltr = chp.filter_from_matcher(self.matcher, self.refresh)
details = await self.finder.info_for(filtr=fltr)
msgs = []
for serial, info in details.items():
msgs.append(DeviceMessages.GetPower(target=serial))
if "multizone" in info["cap"]:
msgs.append(
MultiZoneMessages.GetColorZones(start_index=0, end_index=255, target=serial)
)
elif "chain" in info["cap"]:
msgs.append(
TileMessages.Get64(tile_index=0, length=5, x=0, y=0, width=8, target=serial)
)
else:
msgs.append(LightMessages.GetColor(target=serial))
state = defaultdict(dict)
afr = await self.finder.args_for_run()
async for pkt, _, _ in self.target.script(msgs).run_with(
None, afr, multiple_replies=True, first_wait=0.5
):
if pkt | DeviceMessages.StatePower:
state[pkt.serial]["power"] = pkt.level != 0
elif pkt | LightMessages.LightState:
hsbk = f"kelvin:{pkt.kelvin} saturation:{pkt.saturation} brightness:{pkt.brightness} hue:{pkt.hue}"
state[pkt.serial]["color"] = hsbk
elif pkt | MultiZoneMessages.StateMultiZone:
if "zones" not in state[pkt.serial]:
state[pkt.serial]["zones"] = {}
for i, zi in enumerate(range(pkt.zone_index, pkt.zone_index + 8)):
c = pkt.colors[i]
state[pkt.serial]["zones"][zi] = [c.hue, c.saturation, c.brightness, c.kelvin]
elif pkt | TileMessages.State64:
if "chain" not in state[pkt.serial]:
state[pkt.serial]["chain"] = {}
colors = [[c.hue, c.saturation, c.brightness, c.kelvin] for c in pkt.colors]
state[pkt.serial]["chain"][pkt.tile_index] = colors
scene = []
for serial, info in sorted(state.items()):
if "zones" in info:
info["zones"] = [hsbk for _, hsbk in sorted(info["zones"].items())]
if "chain" in info:
info["chain"] = [hsbks for _, hsbks in sorted(info["chain"].items())]
scene.append({"matcher": {"serial": serial}, **info})
if self.just_return:
return scene
args = {
"uuid": self.uuid,
"scene": scene,
"label": self.label,
"description": self.description,
}
return await self.executor.execute(self.path, {"command": "scene_change", "args": args})
async def execute(self):
fltr = chp.filter_from_matcher(self.matcher)
if self.refresh is not None:
fltr.force_refresh = self.refresh
if self.just_serials:
return await self.finder.serials(filtr=fltr)
else:
return await self.finder.info_for(filtr=fltr)
async def execute(self):
fltr = chp.filter_from_matcher(self.matcher, self.refresh)
kwargs = {}
if self.duration:
kwargs["duration"] = self.duration
msg = PowerToggle(**kwargs)
script = self.target.script(msg)
return await chp.run(
script, fltr, self.finder, add_replies=False, message_timeout=self.timeout
)
async def execute(self):
fltr = chp.filter_from_matcher(self.matcher, self.refresh)
result = chp.ResultBuilder()
afr = await self.finder.args_for_run()
reference = self.finder.find(filtr=fltr)
serials = await tile_serials_from_reference(self.target, reference,
afr)
if not serials:
raise FoundNoDevices("Didn't find any tiles")
await self.target.script(DeviceMessages.SetPower(level=65535)
).run_with_all(serials,
afr,
error_catcher=result.error)
result.result["results"]["tiles"] = await tile_dice(
self.target, serials, afr, error_catcher=result.error)
return result
async def execute(self):
ts = []
result = chp.ResultBuilder()
def get(db):
info = []
for scene in db.queries.get_scenes(uuid=self.uuid).all():
info.append(scene.as_object())
if not info:
raise NoSuchScene(uuid=self.uuid)
return info
for scene in await self.db_queue.request(get):
fltr = chp.filter_from_matcher(scene.matcher, False)
if scene.zones:
multizonefltr = self.clone_fltr_with_cap(fltr, "multizone")
ts.append(hp.async_as_background(self.apply_zones(multizonefltr, scene, result)))
notmultizonefltr = self.clone_fltr_with_no_cap(fltr, "multizone")
ts.append(hp.async_as_background(self.transform(notmultizonefltr, scene, result)))
elif scene.chain:
chainfltr = self.clone_fltr_with_cap(fltr, "chain")
ts.append(hp.async_as_background(self.apply_chain(chainfltr, scene, result)))
notchainfltr = self.clone_fltr_with_no_cap(fltr, "chain")
ts.append(hp.async_as_background(self.transform(notchainfltr, scene, result)))
else:
ts.append(hp.async_as_background(self.transform(fltr, scene, result)))
for t in ts:
try:
await t
except Exception as error:
result.error(error)
return result
async def execute(self):
fltr = chp.filter_from_matcher(self.matcher, self.refresh)
msg = chp.make_message(self.protocol_register, self.pkt_type, self.pkt_args)
script = self.target.script(msg)
return await chp.run(script, fltr, self.finder, message_timeout=self.timeout)
from photons_messages import DeviceMessages, LightMessages, LIFXPacket
from delfick_project.errors_pytest import assertRaises
from delfick_project.norms import sb
from unittest import mock
import asynctest
import pytest
describe "filter_from_matcher":
def assertFilter(self, fltr, **kwargs):
dct = {k: v for k, v in fltr.as_dict().items() if v is not sb.NotSpecified}
assert dct == kwargs
it "returns empty filter if matcher is None":
fltr = chp.filter_from_matcher(None)
self.assertFilter(fltr, force_refresh=False)
fltr = chp.filter_from_matcher(None, refresh=False)
self.assertFilter(fltr, force_refresh=False)
fltr = chp.filter_from_matcher(None, refresh=True)
self.assertFilter(fltr, force_refresh=True)
it "treats a string as a key value string":
fltr = chp.filter_from_matcher("")
self.assertFilter(fltr, force_refresh=False)
fltr = chp.filter_from_matcher("label=one,two hue=20")
self.assertFilter(fltr, force_refresh=False, label=["one", "two"], hue=[(20.0, 20.0)])
