async def write(self, source, received_data, bts):
if not self.attrs.online:
return
addr = None
for service in self.services:
a = service.address(source)
if a:
addr = a
break
if addr is None:
log.warning(
hp.lc(
"Tried to write a packet to the fake device, but no appropriate service found",
source=source,
serial=self.serial,
))
return
log.debug(
hp.lc("RECV",
bts=binascii.hexlify(bts).decode(),
source=source,
serial=self.serial))
pkt = Messages.unpack(bts, self.protocol_register, unknown_ok=True)
if pkt.serial not in ("000000000000", self.serial):
return
async for msg in self.got_message(pkt, source):
await received_data(msg.tobytes(serial=self.serial), addr)
def datagram_received(sp, data, addr):
if not self.online:
return
log.debug(
hp.lc("RECV",
bts=binascii.hexlify(data).decode(),
protocol="udp",
serial=self.serial))
pkt = Messages.unpack(data,
self.protocol_register,
unknown_ok=True)
if pkt.serial not in ("000000000000", self.serial):
return
ack = self.ack_for(pkt, "udp")
if ack:
ack.sequence = pkt.sequence
ack.source = pkt.source
ack.target = self.serial
self.udp_transport.sendto(ack.tobytes(serial=self.serial),
addr)
for res in self.response_for(pkt, "udp"):
res.sequence = pkt.sequence
res.source = pkt.source
res.target = self.serial
self.udp_transport.sendto(res.tobytes(serial=self.serial),
addr)
async def unpack_base64(collector, **kwargs):
"""
Unpack base64 string found after the ``--`` into a json dictionary
``unpack_base64 -- MQAAFIIF7TPQc9USYeIAAAAAAAAAAAMBAAAAAAAAAABmAAAAAPRpAAD//6wNAAAAAA==``
"""
bts = base64.b64decode(collector.configuration["photons_app"].extra)
pkt = Messages.unpack(bts, collector.configuration["protocol_register"], unknown_ok=True)
print(repr(pkt))
async def unpack(collector, **kwargs):
"""
Unpack hexlified string found after the ``--`` into a json dictionary
``unpack -- 310000148205ed33d073d51261e20000000000000000030100000000000000006600000000f4690000ffffac0d00000000``
"""
bts = binascii.unhexlify(collector.configuration["photons_app"].extra)
pkt = Messages.unpack(bts, collector.configuration["protocol_register"], unknown_ok=True)
print(repr(pkt))
async def write(s, transport, bts, original_message):
called.append("write")
pkt = Messages.unpack(bts, protocol_register=protocol_register)
res = DeviceMessages.EchoResponse(
source=pkt.source, sequence=pkt.sequence, target=pkt.target, echoing=b"pong"
)
loop = asyncio.get_event_loop()
bts = res.pack().tobytes()
addr = ("fake://device", 56700)
loop.call_soon(s.session.sync_received_data, bts, addr)
self.assertEqual(msg.payload.actual("skew_ratio"), 3276)
self.assertEqual(msg.payload.actual("waveform"), 1)
self.assertEqual(msg.payload.actual("set_hue"), 1)
self.assertEqual(msg.payload.actual("set_saturation"), 0)
self.assertEqual(msg.payload.actual("set_brightness"), 1)
self.assertEqual(msg.payload.actual("set_kelvin"), 1)
it "SetWaveformOptional does not require all hsbk values":
msg = LightMessages.SetWaveformOptional(hue=100, source=1, sequence=0, target=None)
self.assertIs(msg.actual("brightness"), sb.NotSpecified)
self.assertEqual(msg.set_hue, 1)
self.assertEqual(msg.set_saturation, 0)
self.assertEqual(msg.set_brightness, 0)
self.assertEqual(msg.set_kelvin, 0)
unpackd = Messages.unpack(msg.pack(), protocol_register=protocol_register)
self.assertAlmostEqual(unpackd.hue, 100, places=2)
self.assertEqual(unpackd.set_hue, 1)
self.assertEqual(unpackd.set_saturation, 0)
self.assertEqual(unpackd.saturation, 0)
self.assertEqual(unpackd.set_brightness, 0)
self.assertEqual(unpackd.brightness, 0)
self.assertEqual(unpackd.set_kelvin, 0)
self.assertEqual(unpackd.kelvin, 0)
msg = LightMessages.SetWaveformOptional.empty_normalise(hue=100, source=1, sequence=0, target=None)
self.assertIs(msg.actual("brightness"), Optional)
self.assertEqual(msg.set_hue, 1)
self.assertEqual(msg.set_saturation, 0)
it "converts str to bytes", protocol_register:
data = "AA"
asbytes = binascii.unhexlify(data)
packet_type = mock.Mock(name="packet_type", return_value=(1024, 78))
with mock.patch.object(PacketTypeExtractor, "packet_type", packet_type):
info = Messages.get_packet_type(data, protocol_register)
assert info == (1024, 78, LIFXPacket, M.One, asbytes)
packet_type.assert_called_once_with(asbytes)
describe "unpack":
it "works", protocol_register:
bts = M.One(source=1, sequence=2, target="d073d5000001", one="bl").pack()
pkt = Messages.unpack(bts, protocol_register)
assert pkt | M.One, pkt.__class__
assert pkt.one == "bl"
assert pkt.pack() == bts
it "works with unknown packet", protocol_register:
bts = LIFXPacket(
pkt_type=100, source=1, sequence=2, target="d073d5000001", payload="AA"
).pack()
pkt = Messages.unpack(bts, protocol_register, unknown_ok=True)
assert isinstance(pkt, LIFXPacket)
assert pkt.payload == binascii.unhexlify("AA")
assert pkt.pack() == bts