zigpy-ziggurat 1.2.0__tar.gz → 1.2.2__tar.gz

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-ziggurat
-Version: 1.2.0
+Version: 1.2.2
 Summary: Zigpy radio library for the Ziggurat server
 Author-email: puddly <puddly3@gmail.com>
 License: Apache-2.0
@@ -9,7 +9,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: zigpy>=2.4.0
 Requires-Dist: aiohttp
-Requires-Dist: aiospinel>=1.2.0
+Requires-Dist: aiospinel>=1.3.0
 
 # zigpy-ziggurat
 

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/pyproject.toml

@@ -16,7 +16,7 @@ requires-python = ">=3.12"
 dependencies = [
     "zigpy>=2.4.0",
     "aiohttp",
-    "aiospinel>=1.2.0",
+    "aiospinel>=1.3.0",
 ]
 
 [project.entry-points."zigpy.radio"]

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/tests/test_api.py

@@ -488,12 +488,37 @@ async def test_connection_lost_fails_pending_requests(
     assert api.disconnects == [None]
 
 
+async def test_startup_hello_ignored(
+    api: RecordingApi, transport: SyntheticBinaryTransport
+) -> None:
+    async def start_then_reply(request: p.Request, request_id: int) -> None:
+        transport.notify(
+            p.NotificationCommand.HELLO,
+            0,
+            p.Hello(
+                protocol_version=t.uint8_t(p.PROTOCOL_VERSION),
+                configured=t.Bool(False),
+            ),
+        )
+        transport.ok(request.command, request_id)
+
+    # Embedded firmware starts its stack on the first host frame and announces it
+    # with a `hello` before the reply: that opens the session, it is not a reboot
+    transport.handlers[p.RequestCommand.RESET] = start_then_reply
+    assert await api.request(p.Reset(hard=t.Bool(False))) is None
+
+    assert api.disconnects == []
+    assert api.notifications == []
+
+
 async def test_hello_reported_as_disconnect(
     api: RecordingApi, transport: SyntheticBinaryTransport
 ) -> None:
     async def withhold(request: p.Request, request_id: int) -> None:
         return None
 
+    assert await api.request(p.Shutdown()) is None
+
     transport.handlers[p.RequestCommand.SHUTDOWN] = withhold
     request = asyncio.ensure_future(api.request(p.Shutdown()))
     await asyncio.sleep(0)

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/tests/test_application.py

@@ -471,6 +471,59 @@ async def test_write_network_info_restores_children(
     assert [entry.nwk for entry in entries] == list(nwk_addresses.values())
     # The backup carries no capability, so the device type is unknown
     assert {entry.device_type for entry in entries} == {p.ChildDeviceType.UNKNOWN}
+    assert {entry.rx_on_when_idle for entry in entries} == {0}
+
+
+async def test_write_network_info_restores_children_capability(
+    connected_app: ControllerApplication, server: SyntheticZiggurat
+) -> None:
+    """A child's capability comes from its node descriptor, so an end device that
+    keeps its receiver on is not restored as sleepy."""
+    app = connected_app
+    await app.load_network_info()
+
+    def child(
+        n: int, mac_capability_flags: int | None, logical_type: zdo_t.LogicalType | None
+    ) -> t.EUI64:
+        ieee = t.EUI64([n] * 8)
+        device = app.add_device(ieee, t.NWK(0x1000 + n))
+        if mac_capability_flags is not None:
+            device.node_desc = zdo_t.NodeDescriptor(
+                logical_type=logical_type,
+                mac_capability_flags=zdo_t.NodeDescriptor.MACCapabilityFlags(
+                    mac_capability_flags
+                ),
+            )
+        return ieee
+
+    children = [
+        # A Sengled bulb: an end device with its receiver on
+        child(1, 0x8C, zdo_t.LogicalType.EndDevice),
+        # A battery sensor
+        child(2, 0x80, zdo_t.LogicalType.EndDevice),
+        child(3, 0x8E, zdo_t.LogicalType.Router),
+        # Not interviewed
+        child(4, None, None),
+        # A node descriptor with no logical type
+        child(5, 0x80, None),
+    ]
+
+    await app.write_network_info(
+        network_info=app.state.network_info.replace(
+            children=children,
+            nwk_addresses={ieee: app.get_device(ieee=ieee).nwk for ieee in children},
+        ),
+        node_info=app.state.node_info,
+    )
+
+    (load,) = server.sent(p.LoadChildren)
+    assert [(entry.device_type, entry.rx_on_when_idle) for entry in load.entries] == [
+        (p.ChildDeviceType.END_DEVICE, 1),
+        (p.ChildDeviceType.END_DEVICE, 0),
+        (p.ChildDeviceType.ROUTER, 1),
+        (p.ChildDeviceType.UNKNOWN, 0),
+        (p.ChildDeviceType.UNKNOWN, 0),
+    ]
 
 
 async def test_permit_ncp(
@@ -745,6 +798,19 @@ async def test_send_packet_encrypted_without_eui64(
     assert server.sent(p.SendUnicast) == []
 
 
+async def test_send_packet_disconnected(
+    app: ControllerApplication, server: SyntheticZiggurat
+) -> None:
+    await app.disconnect()
+
+    with pytest.raises(DeliveryError, match="Not connected"):
+        await app.send_packet(
+            aps_packet(t.AddrModeAddress(addr_mode=t.AddrMode.NWK, address=DEVICE_NWK))
+        )
+
+    assert server.sent(p.SendUnicast) == []
+
+
 async def test_send_packet_broadcast(
     app: ControllerApplication, server: SyntheticZiggurat
 ) -> None:
@@ -1127,12 +1193,13 @@ async def test_on_notification_received_aps_zdo_reply_encryption(
 
 
 @pytest.mark.parametrize(
-    ("destination", "group", "expected_dst"),
+    ("destination", "group", "expected_dst", "expected_dst_ep"),
     [
         (
             t.NWK(0x0000),
             2,
             t.AddrModeAddress(addr_mode=t.AddrMode.Group, address=t.Group(2)),
+            None,
         ),
         (
             t.NWK(0xFFFD),
@@ -1140,11 +1207,13 @@ async def test_on_notification_received_aps_zdo_reply_encryption(
             t.AddrModeAddress(
                 addr_mode=t.AddrMode.Broadcast, address=t.BroadcastAddress(0xFFFD)
             ),
+            1,
         ),
         (
             t.NWK(0x0000),
             None,
             t.AddrModeAddress(addr_mode=t.AddrMode.NWK, address=t.NWK(0x0000)),
+            1,
         ),
     ],
 )
@@ -1153,9 +1222,10 @@ async def test_on_notification_received_aps_address_modes(
     destination: t.NWK,
     group: int | None,
     expected_dst: t.AddrModeAddress,
+    expected_dst_ep: int | None,
 ) -> None:
     """A group id, a broadcast address and a plain network address each decode into
-    their own zigpy address mode."""
+    their own zigpy address mode. A group frame has no destination endpoint."""
     app = RecordingApplication(make_app_config(server.url))
     await app.connect()
     await app.start_network()
@@ -1184,6 +1254,7 @@ async def test_on_notification_received_aps_address_modes(
     assert len(app.packets) == 1
     packet = app.packets[0]
     assert packet.dst == expected_dst
+    assert packet.dst_ep == expected_dst_ep
     assert packet.src == t.AddrModeAddress(addr_mode=t.AddrMode.NWK, address=DEVICE_NWK)
     assert packet.lqi == 200
     assert packet.rssi == -70

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/tests/test_transport.py

@@ -3,7 +3,7 @@ the transports it returns."""
 
 import asyncio
 
-import aiospinel
+from aiospinel import PropertyStatusError, Status
 import pytest
 
 from tests.common import (
@@ -97,7 +97,7 @@ async def test_spinel_stream_frame_handler_error(
 
 
 async def test_spinel_connect_rejects_foreign_firmware() -> None:
-    rcp = SyntheticSpinelRcp(get_prop_id=aiospinel.PackedUInt21(0x0001))
+    rcp = SyntheticSpinelRcp(get_status=Status.PROP_NOT_FOUND)
     await rcp.start()
     try:
         with pytest.raises(ConnectionError, match="does not embed"):
@@ -107,11 +107,11 @@ async def test_spinel_connect_rejects_foreign_firmware() -> None:
 
 
 async def test_spinel_tunnel_write_rejected() -> None:
-    rcp = SyntheticSpinelRcp(set_prop_id=aiospinel.PackedUInt21(0x0001))
+    rcp = SyntheticSpinelRcp(set_status=Status.INVALID_ARGUMENT)
     await rcp.start()
     transport = await connect_transport(rcp.url, lambda frame: None, lambda exc: None)
     try:
-        with pytest.raises(ConnectionError, match="Tunnel write rejected"):
+        with pytest.raises(PropertyStatusError):
             await transport.send_frame(b"\x01")
     finally:
         await transport.disconnect()

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/zigpy_ziggurat/zigbee/api.py

@@ -56,6 +56,7 @@ class ZigguratApi:
         ] = {}
         self._awaiting_aps_ack: set[int] = set()
         self._transport: Transport | None = None
+        self._received_frame = False
 
     async def connect(self) -> None:
         self._transport = await connect_transport(
@@ -201,6 +202,8 @@ class ZigguratApi:
             _LOGGER.debug("Received notification (id=%d): %r", request_id, notification)
             self._handle_notification(request_id, notification)
 
+        self._received_frame = True
+
     def _handle_response(self, request_id: int, body: bytes) -> None:
         pending = self._pending.get(request_id)
         if pending is None or pending.response.done():
@@ -261,7 +264,11 @@ class ZigguratApi:
             if confirm is not None and not confirm.done():
                 confirm.set_result(notification)
         elif isinstance(notification, p.Hello):
-            # The firmware only sends `hello` when it reboots
+            # Embedded firmware starts its stack on the first frame the host sends, and
+            # the stack announces itself before it answers. So a `hello` that opens the
+            # session is that start. Any later `hello` means the firmware rebooted.
+            if not self._received_frame:
+                return
             self._connection_lost(ConnectionError("Ziggurat firmware reset"))
         elif isinstance(notification, p.LastReset):
             logging.getLogger("ziggurat.fw").warning(

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/zigpy_ziggurat/zigbee/application.py

@@ -541,16 +541,9 @@ class ControllerApplication(zigpy.application.ControllerApplication):
 
     async def _restore_children(self, network_info: zigpy.state.NetworkInfo) -> None:
         assert self._api is not None
-        # The backup carries no capability, so device type is Unknown (restored as a
-        # sleepy end device); children without a known NWK address can't be loaded.
+        # Children without a known NWK address can't be loaded
         entries = [
-            p.ChildEntry(
-                ieee=ieee,
-                nwk=network_info.nwk_addresses[ieee],
-                rx_on_when_idle=t.uint1_t(1),
-                device_type=p.ChildDeviceType.UNKNOWN,
-                reserved=t.uint5_t(0),
-            )
+            self._child_entry(ieee, network_info.nwk_addresses[ieee])
             for ieee in network_info.children
             if ieee in network_info.nwk_addresses
         ]
@@ -563,6 +556,41 @@ class ControllerApplication(zigpy.application.ControllerApplication):
                 )
             )
 
+    def _child_entry(self, ieee: t.EUI64, nwk: t.NWK) -> p.ChildEntry:
+        # The backup carries no capability, so it comes from the child's node
+        # descriptor. Some end devices keep their receiver on and never poll (Sengled
+        # bulbs), so they must not be restored as sleepy. Without a node descriptor
+        # the child is restored as a sleepy end device, as most end devices are.
+        try:
+            device = self.get_device(ieee=ieee)
+        except KeyError:
+            node_desc = None
+        else:
+            # A child joined the network, so it is never a GPD
+            assert isinstance(device, zigpy.device.ZigbeeDevice)
+            node_desc = device.node_desc
+
+        if node_desc is None:
+            device_type = p.ChildDeviceType.UNKNOWN
+            rx_on_when_idle = False
+        else:
+            if node_desc.is_router:
+                device_type = p.ChildDeviceType.ROUTER
+            elif node_desc.is_end_device:
+                device_type = p.ChildDeviceType.END_DEVICE
+            else:
+                device_type = p.ChildDeviceType.UNKNOWN
+
+            rx_on_when_idle = bool(node_desc.is_receiver_on_when_idle)
+
+        return p.ChildEntry(
+            ieee=ieee,
+            nwk=nwk,
+            rx_on_when_idle=t.uint1_t(rx_on_when_idle),
+            device_type=device_type,
+            reserved=t.uint5_t(0),
+        )
+
     async def reset_network_info(self) -> None:
         assert self._api is not None
         await self._api.request(p.Shutdown())
@@ -778,11 +806,16 @@ class ControllerApplication(zigpy.application.ControllerApplication):
 
     def _handle_received_aps_command(self, command: p.ReceivedAps) -> None:
         group = command.group_id
+        dst_ep: t.uint8_t | None = command.dst_ep
+
         if group is not None:
             dst = t.AddrModeAddress(
                 addr_mode=t.AddrMode.Group,
                 address=t.Group(group),
             )
+            # A group frame carries no destination endpoint, so `dst_ep` is filler.
+            # Passing it on would make zigpy treat a filler of 0 as ZDO.
+            dst_ep = None
         elif command.destination >= 0xFFF8:
             dst = t.AddrModeAddress(
                 addr_mode=t.AddrMode.Broadcast,
@@ -801,7 +834,7 @@ class ControllerApplication(zigpy.application.ControllerApplication):
             ),
             dst=dst,
             src_ep=command.src_ep,
-            dst_ep=command.dst_ep,
+            dst_ep=dst_ep,
             profile_id=command.profile_id,
             cluster_id=command.cluster_id,
             lqi=command.lqi,
@@ -865,7 +898,6 @@ class ControllerApplication(zigpy.application.ControllerApplication):
         # Resolves once the send is confirmed: passive-ack quorum for a broadcast or
         # groupcast, next-hop acceptance for a no-ack unicast, or the end-to-end APS
         # ack. A rejected or failed send raises `DeliveryError`.
-        assert self._api is not None
         priority = packet.priority if packet.priority is not None else 0
         radius = packet.radius or 30
         asdu = packet.data.serialize()
@@ -942,4 +974,8 @@ class ControllerApplication(zigpy.application.ControllerApplication):
                     asdu=asdu,
                 )
 
+            # The connection can close while the send waits for a concurrency slot
+            if self._api is None:
+                raise DeliveryError("Not connected to Ziggurat")
+
             await self._api.request_confirmed(send)

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/zigpy_ziggurat/zigbee/transport.py

@@ -8,14 +8,14 @@ import logging
 from typing import Any, Protocol, cast
 
 import aiohttp
-import aiospinel
+from aiospinel import PropertyStatusError, SpinelProtocol
 import zigpy.serial
 
 _LOGGER = logging.getLogger(__name__)
 
 WEBSOCKET_HEARTBEAT = 15
 
-PROP_VENDOR_ZIGGURAT = aiospinel.PackedUInt21(0x3D5A)
+PROP_VENDOR_ZIGGURAT = 0x3D5A
 
 # The callback the API installs to receive a device -> host binary frame.
 OnFrame = Callable[[bytes], None]
@@ -56,7 +56,7 @@ async def connect_transport(
 # -- serial (Spinel tunnel) ------------------------------------------------------
 
 
-class _SpinelProtocol(aiospinel.SpinelProtocol):
+class _SpinelProtocol(SpinelProtocol):
     """Tunnels binary frames over the vendor Spinel stream property."""
 
     def __init__(self, on_frame: OnFrame, on_lost: OnLost) -> None:
@@ -80,32 +80,18 @@ class _SpinelProtocol(aiospinel.SpinelProtocol):
             _LOGGER.exception("Failed to handle frame: %r", data)
 
     async def start_ziggurat(self) -> None:
-        rsp = await self.send_command(
-            aiospinel.CommandID.PROP_VALUE_GET,
-            PROP_VENDOR_ZIGGURAT.serialize(),
-        )
-        prop_id, _ = aiospinel.PackedUInt21.deserialize(rsp.data)
-        if prop_id != PROP_VENDOR_ZIGGURAT:
-            raise ConnectionError(
-                f"Firmware does not embed the Ziggurat stack: {rsp!r}"
-            )
+        try:
+            await self.get_property(PROP_VENDOR_ZIGGURAT)
+        except PropertyStatusError as exc:
+            raise ConnectionError("Firmware does not embed the Ziggurat stack") from exc
         _LOGGER.debug("Embedded Ziggurat firmware detected")
 
     async def tunnel_send(self, frame: bytes) -> None:
         # No retries: a timed-out tunnel write must not resend the request (the first
         # copy may already have been processed).
-        rsp = await self.send_command(
-            aiospinel.CommandID.PROP_VALUE_SET,
-            (
-                PROP_VENDOR_ZIGGURAT.serialize()
-                + len(frame).to_bytes(2, "little")
-                + frame
-            ),
-            retries=0,
+        await self.set_property(
+            PROP_VENDOR_ZIGGURAT, len(frame).to_bytes(2, "little") + frame, retries=0
         )
-        prop_id, _ = aiospinel.PackedUInt21.deserialize(rsp.data)
-        if prop_id != PROP_VENDOR_ZIGGURAT:
-            raise ConnectionError(f"Tunnel write rejected: {rsp!r}")
 
 
 class SpinelTransport:
@@ -141,8 +127,7 @@ class SpinelTransport:
 
     async def disconnect(self) -> None:
         if self._protocol is not None:
-            self._protocol.close()
-            await self._protocol.wait_until_closed()
+            await self._protocol.disconnect()
             self._protocol = None
 
     async def send_frame(self, frame: bytes) -> None:

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/zigpy_ziggurat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-ziggurat
-Version: 1.2.0
+Version: 1.2.2
 Summary: Zigpy radio library for the Ziggurat server
 Author-email: puddly <puddly3@gmail.com>
 License: Apache-2.0
@@ -9,7 +9,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: zigpy>=2.4.0
 Requires-Dist: aiohttp
-Requires-Dist: aiospinel>=1.2.0
+Requires-Dist: aiospinel>=1.3.0
 
 # zigpy-ziggurat
 

{zigpy_ziggurat-1.2.0 → zigpy_ziggurat-1.2.2}/zigpy_ziggurat.egg-info/requires.txt

@@ -1,3 +1,3 @@
 zigpy>=2.4.0
 aiohttp
-aiospinel>=1.2.0
+aiospinel>=1.3.0