zigpy-zboss 2.0.2__tar.gz → 2.0.4__tar.gz

{zigpy_zboss-2.0.2/zigpy_zboss.egg-info → zigpy_zboss-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-zboss
-Version: 2.0.2
+Version: 2.0.4
 Summary: A library for zigpy which communicates with Nordic nRF52 radios running ZBOSS NCP
 Author-email: Damien Kastner <damien.kastner@kardia.no>
 License: GPL-3.0

{zigpy_zboss-2.0.2 → zigpy_zboss-2.0.4}/tests/test_uart.py

@@ -280,6 +280,42 @@ async def test_connection_lost(dummy_serial_conn, mocker, event_loop):
     assert (await conn_lost_fut) == exception
 
 
+@pytest.mark.asyncio
+async def test_connect_url_port_skips_path_check(mocker, event_loop):
+    """A URL-style port (``socket://``/``tcp://``) has no filesystem path.
+
+    ``connect()`` must not gate on ``os.path.exists`` for such ports, otherwise
+    it spins in the retry loop until the timeout and never opens the connection
+    (regression for ser2net bridges and native-TCP NCPs).
+    """
+    target_url = "socket://127.0.0.1:6638"
+
+    def create_serial_conn(loop, protocol_factory, url, *args, **kwargs):
+        assert url == target_url
+        fut = event_loop.create_future()
+        protocol = protocol_factory()
+        event_loop.add_writer = lambda *a, **k: None
+        event_loop.add_reader = lambda *a, **k: None
+        event_loop.remove_writer = lambda *a, **k: None
+        event_loop.remove_reader = lambda *a, **k: None
+        transport = mocker.Mock()
+        transport.serial = mocker.Mock()
+        protocol.connection_made(transport)
+        fut.set_result((transport, protocol))
+        return fut
+
+    mocker.patch("serialx.create_serial_connection", new=create_serial_conn)
+    # A socket:// path never exists on disk; the check must be skipped for it.
+    exists = mocker.patch("zigpy_zboss.uart.os.path.exists", return_value=False)
+
+    protocol = await zboss_uart.connect(
+        conf.SCHEMA_DEVICE({conf.CONF_DEVICE_PATH: target_url}), api=mocker.Mock()
+    )
+
+    assert protocol is not None
+    exists.assert_not_called()
+
+
 # ToFix: this is not testing the uart test_connection_made method
 # @pytest.mark.asyncio
 # async def test_connection_made(dummy_serial_conn, mocker):

{zigpy_zboss-2.0.2 → zigpy_zboss-2.0.4}/zigpy_zboss/__init__.py

@@ -2,7 +2,7 @@
 
 MAJOR_VERSION = 2
 MINOR_VERSION = 0
-PATCH_VERSION = 2
+PATCH_VERSION = 4
 
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"

{zigpy_zboss-2.0.2 → zigpy_zboss-2.0.4}/zigpy_zboss/uart.py

@@ -288,8 +288,14 @@ async def connect(config: conf.ConfigType, api) -> ZbossNcpProtocol:
     last_exc: OSError | None = None
     protocol = None
 
+    # URL-style ports (``socket://``, ``tcp://``, ``rfc2217://``, …) are not
+    # filesystem paths, so the local-device existence check below must be
+    # skipped for them; otherwise the loop spins until the timeout and the
+    # connection is never opened (e.g. ser2net or a native TCP NCP).
+    is_local_device = "://" not in port
+
     while loop.time() < deadline:
-        if not os.path.exists(port):
+        if is_local_device and not os.path.exists(port):
             await asyncio.sleep(CONNECT_OPEN_RETRY_DELAY)
             continue
 

{zigpy_zboss-2.0.2 → zigpy_zboss-2.0.4}/zigpy_zboss/zigbee/application.py

@@ -652,20 +652,42 @@ class ControllerApplication(zigpy.application.ControllerApplication):
         if dev:
             self.handle_leave(nwk=dev.nwk, ieee=msg.IEEE)
 
+    def _should_handle_join(self, nwk: t.NWK, ieee: t.EUI64) -> bool:
+        """Whether a join signal is worth passing on to zigpy.
+
+        `Device_annce` is a broadcast that routers rebroadcast, so the same
+        join arrives several times, and the NCP reports its own indications
+        alongside it. `handle_join` restarts a running interview, so the
+        repeats have to be dropped while one is still in flight.
+        """
+        device = self.devices.get(ieee)
+        return device is None or device.nwk != nwk or device.is_initialized
+
     def on_zdo_device_announcement(self, msg: c.ZDO.DevAnnceInd.Ind):
         """ZDO Device announcement command received."""
-        self.handle_join(nwk=msg.NWK, ieee=msg.IEEE, parent_nwk=None)
+        if self._should_handle_join(msg.NWK, msg.IEEE):
+            self.handle_join(nwk=msg.NWK, ieee=msg.IEEE, parent_nwk=None)
 
     def on_dev_update(self, msg: c.ZDO.DevUpdateInd.Ind):
         """Device update indication."""
         if msg.Status == t_zboss.DeviceUpdateStatus.secured_rejoin:
-            self.handle_join(msg.Nwk, msg.IEEE, 0x0000)
+            if self._should_handle_join(msg.Nwk, msg.IEEE):
+                self.handle_join(msg.Nwk, msg.IEEE, 0x0000)
         elif msg.Status == t_zboss.DeviceUpdateStatus.unsecured_join:
-            self.handle_join(msg.Nwk, msg.IEEE, 0x0000)
+            # A fresh association: the device has no network key yet and
+            # cannot answer, so interviewing it now only adds traffic while
+            # it is still finishing the handshake. The announcement or the
+            # authorization indication brings it in once it is really on.
+            LOGGER.debug(
+                "Device %s associated as 0x%04x, waiting for it to join",
+                msg.IEEE,
+                msg.Nwk,
+            )
         elif msg.Status == t_zboss.DeviceUpdateStatus.device_left:
             self.handle_leave(msg.Nwk, msg.IEEE)
         elif msg.Status == t_zboss.DeviceUpdateStatus.tc_rejoin:
-            self.handle_join(msg.Nwk, msg.IEEE, 0x0000)
+            if self._should_handle_join(msg.Nwk, msg.IEEE):
+                self.handle_join(msg.Nwk, msg.IEEE, 0x0000)
 
     def on_dev_authorized(self, msg: c.ZDO.DevAuthorizedInd.Ind):
         """TC device authorized indication."""
@@ -677,6 +699,13 @@ class ControllerApplication(zigpy.application.ControllerApplication):
             )
             # ZBOSS NCP will kick the device and reset; proactively clean up
             self.handle_leave(msg.Nwk, msg.IEEE)
+            return
+
+        # `Device_annce` is a broadcast and can be lost, while this
+        # indication is generated locally by the NCP, so it has to be able
+        # to bring the device in on its own.
+        if self._should_handle_join(msg.Nwk, msg.IEEE):
+            self.handle_join(msg.Nwk, msg.IEEE, 0x0000)
 
     def on_apsde_indication(self, msg):
         """APSDE-DATA.indication handler."""

zigpy_zboss-2.0.4/zigpy_zboss/zigbee/device.py

@@ -0,0 +1,461 @@
+"""Zigbee device object."""
+import logging
+from typing import Any
+
+import zigpy.device
+import zigpy.endpoint
+import zigpy.exceptions
+import zigpy.types as t
+import zigpy.util
+from zigpy.zdo import ZDO as ZigpyZDO
+from zigpy.zdo import types as zdo_t
+
+import zigpy_zboss.types as t_zboss
+from zigpy_zboss import commands as c
+
+LOGGER = logging.getLogger(__name__)
+
+# A ZDO command is only answered once the on-air transaction resolves,
+# which takes the NCP up to a minute for an unreachable device. zigpy
+# cancels its own requests long before this, so it is only a backstop
+# for paths that impose no deadline of their own, such as broadcasts.
+ZDO_TIMEOUT = 70
+
+
+class ZbossZDO(ZigpyZDO):
+    """The ZDO endpoint of a ZBOSS device.
+
+    The ZBOSS NCP has no APSDE path for ZDO: every ZDO request has to be sent
+    as its own NCP command. Rather than overriding the individual `*_req`
+    methods, which quirks discard when they replace a device object, the
+    translation happens in `zboss_specific_cmd` on the outgoing packet. That
+    hook lives on the coordinator, which is never quirked, so every device
+    takes the same path and gets standard zigpy return values.
+    """
+
+    def handle_mgmt_permit_joining_req(
+        self,
+        permit_duration: int,
+        tc_significance: int,
+    ):
+        """Handle ZDO permit joining request."""
+        hdr = zdo_t.ZDOHeader(zdo_t.ZDOCmd.Mgmt_Permit_Joining_req, 0)
+        dst_addressing = t.Addressing.IEEE
+
+        self.listener_event("permit_duration", permit_duration)
+        self.listener_event(
+            "zdo_mgmt_permit_joining_req",
+            self._device,
+            dst_addressing,
+            hdr,
+            (permit_duration, tc_significance),
+        )
+
+    async def Mgmt_NWK_Update_req(self, nwkUpdate):
+        """Issue a ZDO Mgmt_NWK_Update (energy scan / channel change).
+
+        Kept as an override: an energy scan can take longer than zigpy's APS
+        reply timeout, so it must not go through `Device.request`. It is only
+        ever issued on the coordinator, which quirks never replace.
+        """
+        res = await self._device._application._api.request(
+            c.ZDO.MgmtNwkUpdate.Req(
+                TSN=self._device._application.get_sequence(),
+                ScanChannelMask=nwkUpdate.ScanChannels,
+                ScanDuration=nwkUpdate.ScanDuration,
+                ScanCount=nwkUpdate.ScanCount or 0,
+                MgrAddr=self._device.nwk,
+                DstNWK=t.NWK(0x0000),
+            )
+        )
+        if res.StatusCode != 0:
+            raise zigpy.exceptions.DeliveryError(
+                f"Mgmt_NWK_Update_req failed: {res.StatusCode}",
+                status=res.StatusCode,
+            )
+        return (None, res.ScannedChannels, None, None, res.EnergyValues)
+
+    async def zboss_specific_cmd(self, packet: t.ZigbeePacket) -> None:
+        """Reroute ZDO packets sent over APSDE to ZBOSS ZDO commands."""
+        try:
+            zdo_hdr, zdo_args = self.deserialize(
+                cluster_id=packet.cluster_id, data=packet.data.serialize()
+            )
+        except ValueError:
+            LOGGER.debug("Could not parse ZDO message from packet")
+            return
+
+        handler = self._ZDO_PACKET_HANDLERS.get(zdo_hdr.command_id)
+
+        if handler is not None:
+            await handler(self, packet, zdo_hdr, zdo_args)
+            return
+
+        is_response = bool(zdo_hdr.command_id & 0x8000)
+        is_unicast = packet.dst.addr_mode in (t.AddrMode.NWK, t.AddrMode.IEEE)
+
+        # Only unicast requests have a caller waiting on a reply. Dropping one
+        # silently would stall that caller until it times out.
+        if is_response or not is_unicast:
+            LOGGER.debug("Dropping unsupported ZDO packet: %r", packet)
+            return
+
+        raise zigpy.exceptions.DeliveryError(
+            f"ZBOSS NCP cannot send ZDO command {zdo_hdr.command_id!r}"
+        )
+
+    @property
+    def _api(self):
+        """Return the NCP API of the application this ZDO belongs to."""
+        return self._device._application._api
+
+    def _next_tsn(self) -> int:
+        """Return the next NCP transmission sequence number."""
+        return self._device._application.get_sequence()
+
+    def _target_nwk(self, packet: t.ZigbeePacket) -> t.NWK:
+        """Return the NWK address a ZDO packet is addressed to."""
+        if packet.dst.addr_mode != t.AddrMode.IEEE:
+            return t.NWK(packet.dst.address)
+
+        try:
+            device = self._device._application.get_device(
+                ieee=packet.dst.address
+            )
+        except KeyError as exc:
+            raise zigpy.exceptions.DeliveryError(
+                f"Cannot send ZDO request to unknown device {packet.dst!r}"
+            ) from exc
+
+        return t.NWK(device.nwk)
+
+    def _send_zdo_rsp(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            *values: Any,
+            src: t.AddrModeAddress | None = None) -> None:
+        """Feed a synthesized ZDO response back into zigpy.
+
+        `src` defaults to the request's destination, which is what zigpy
+        matches the pending request against. Broadcast requests have to
+        override it with the address that actually answered.
+        """
+        rsp_cmd = zdo_t.ZDOCmd(zdo_hdr.command_id | 0x8000)
+        _, schema = zdo_t.CLUSTERS[rsp_cmd]
+
+        args = list(values)
+        while args and args[-1] is None:
+            args.pop()
+
+        data = t.uint8_t(zdo_hdr.tsn).serialize() + t.serialize(args, schema)
+
+        self._device._application.packet_received(
+            t.ZigbeePacket(
+                src=packet.dst if src is None else src,
+                src_ep=0,
+                dst=t.AddrModeAddress(
+                    addr_mode=t.AddrMode.NWK,
+                    address=t.NWK(0x0000),
+                ),
+                dst_ep=0,
+                tsn=zdo_hdr.tsn,
+                profile_id=0,
+                cluster_id=rsp_cmd,
+                data=t.SerializableBytes(data),
+                tx_options=t.TransmitOptions.NONE,
+                lqi=None,
+                rssi=None,
+            )
+        )
+
+    @staticmethod
+    def _bind_dst_address(dst_address: zdo_t.MultiAddress):
+        """Convert a ZDO bind destination into ZBOSS addressing."""
+        if dst_address.addrmode == t.AddrMode.IEEE:
+            return (
+                t_zboss.BindAddrMode.IEEE,
+                dst_address.ieee,
+                dst_address.endpoint,
+            )
+
+        # ZBOSS does not support the NWK mode for binding
+        if dst_address.addrmode != t.AddrMode.Group:
+            raise zigpy.exceptions.DeliveryError(
+                f"Unsupported bind address mode: {dst_address.addrmode!r}"
+            )
+
+        # A group destination carries no endpoint, but ZBOSS always wants one
+        return (
+            t_zboss.BindAddrMode.Group,
+            t.EUI64(
+                [
+                    dst_address.nwk % 0x100,
+                    dst_address.nwk >> 8,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ]
+            ),
+            t.uint8_t(0),
+        )
+
+    async def _bind_req(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            zdo_args: tuple[Any]) -> None:
+        """Send ZDO bind request and handle the response."""
+        src_ieee, src_ep, cluster_id, dst_address = zdo_args
+        addr_mode, dst_addr, dst_ep = self._bind_dst_address(dst_address)
+
+        res = await self._api.request(
+            c.ZDO.BindReq.Req(
+                TSN=self._next_tsn(),
+                TargetNwkAddr=self._target_nwk(packet),
+                SrcIEEE=src_ieee,
+                SrcEndpoint=src_ep,
+                ClusterId=cluster_id,
+                DstAddrMode=addr_mode,
+                DstAddr=dst_addr,
+                DstEndpoint=dst_ep,
+            ),
+            timeout=ZDO_TIMEOUT,
+        )
+        self._send_zdo_rsp(packet, zdo_hdr, res.StatusCode)
+
+    async def _unbind_req(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            zdo_args: tuple[Any]) -> None:
+        """Send ZDO unbind request and handle the response."""
+        src_ieee, src_ep, cluster_id, dst_address = zdo_args
+        addr_mode, dst_addr, dst_ep = self._bind_dst_address(dst_address)
+
+        res = await self._api.request(
+            c.ZDO.UnbindReq.Req(
+                TSN=self._next_tsn(),
+                TargetNwkAddr=self._target_nwk(packet),
+                SrcIEEE=src_ieee,
+                SrcEndpoint=src_ep,
+                ClusterId=cluster_id,
+                DstAddrMode=addr_mode,
+                DstAddr=dst_addr,
+                DstEndpoint=dst_ep,
+            ),
+            timeout=ZDO_TIMEOUT,
+        )
+        self._send_zdo_rsp(packet, zdo_hdr, res.StatusCode)
+
+    async def _node_desc_req(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            zdo_args: tuple[Any]) -> None:
+        """Send ZDO node descriptor request and handle the response."""
+        (nwk,) = zdo_args
+        res = await self._api.request(
+            c.ZDO.NodeDescReq.Req(TSN=self._next_tsn(), NwkAddr=nwk),
+            timeout=ZDO_TIMEOUT,
+        )
+        node_desc = None if res.StatusCode else res.NodeDesc
+
+        self._send_zdo_rsp(packet, zdo_hdr, res.StatusCode, nwk, node_desc)
+
+    async def _active_ep_req(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            zdo_args: tuple[Any]) -> None:
+        """Send ZDO active endpoints request and handle the response."""
+        (nwk,) = zdo_args
+        res = await self._api.request(
+            c.ZDO.ActiveEpReq.Req(TSN=self._next_tsn(), NwkAddr=nwk),
+            timeout=ZDO_TIMEOUT,
+        )
+        # Active_EP_rsp has no optional endpoint list, so it cannot be omitted
+        endpoints = [] if res.StatusCode else res.ActiveEpList
+
+        self._send_zdo_rsp(packet, zdo_hdr, res.StatusCode, nwk, endpoints)
+
+    async def _simple_desc_req(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            zdo_args: tuple[Any]) -> None:
+        """Send ZDO simple descriptor request and handle the response."""
+        nwk, endpoint = zdo_args
+        res = await self._api.request(
+            c.ZDO.SimpleDescriptorReq.Req(
+                TSN=self._next_tsn(), NwkAddr=nwk, Endpoint=endpoint
+            ),
+            timeout=ZDO_TIMEOUT,
+        )
+
+        if res.StatusCode:
+            desc = None
+        else:
+            desc = zdo_t.SizePrefixedSimpleDescriptor(
+                endpoint=res.SimpleDesc.endpoint,
+                profile=res.SimpleDesc.profile,
+                device_type=res.SimpleDesc.device_type,
+                device_version=res.SimpleDesc.device_version,
+                input_clusters=res.SimpleDesc.input_clusters,
+                output_clusters=res.SimpleDesc.output_clusters,
+            )
+
+        self._send_zdo_rsp(packet, zdo_hdr, res.StatusCode, nwk, desc)
+
+    async def _mgmt_lqi_req(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            zdo_args: tuple[Any]) -> None:
+        """Send ZDO LQI request and handle the response."""
+        (start_index,) = zdo_args
+        res = await self._api.request(
+            c.ZDO.MgmtLqi.Req(
+                TSN=self._next_tsn(),
+                DestNWK=self._target_nwk(packet),
+                Index=start_index,
+            ),
+            timeout=ZDO_TIMEOUT,
+        )
+        neighbors = None if res.StatusCode else res.Neighbors
+
+        self._send_zdo_rsp(packet, zdo_hdr, res.StatusCode, neighbors)
+
+    async def _mgmt_leave_req(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            zdo_args: tuple[Any]) -> None:
+        """Send ZDO leave request and handle the response."""
+        ieee, options = zdo_args
+        res = await self._api.request(
+            c.ZDO.MgtLeave.Req(
+                TSN=self._next_tsn(),
+                DestNWK=self._target_nwk(packet),
+                IEEE=t.EUI64(ieee),
+                Flags=t.uint8_t(options),
+            ),
+            timeout=ZDO_TIMEOUT,
+        )
+        self._send_zdo_rsp(packet, zdo_hdr, res.StatusCode)
+
+    async def _mgmt_permit_joining_req(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            zdo_args: tuple[Any]) -> None:
+        """Send ZDO permit joining request and handle the response.
+
+        `app.permit()` already broadcasts this and then opens the coordinator
+        via `permit_ncp`, so forwarding the broadcast here would send it
+        twice. Only the targeted form is translated.
+        """
+        if packet.dst.addr_mode not in (t.AddrMode.NWK, t.AddrMode.IEEE):
+            LOGGER.debug("Dropping broadcast permit joining request")
+            return
+
+        duration, tc_significance = zdo_args
+        res = await self._api.request(
+            c.ZDO.PermitJoin.Req(
+                TSN=self._next_tsn(),
+                # Targeting `self._target_nwk(packet)` would be correct, but
+                # this has always gone out as a broadcast and changing where
+                # joins are opened deserves its own change.
+                DestNWK=t.NWK(t.BroadcastAddress.RX_ON_WHEN_IDLE),
+                PermitDuration=t.uint8_t(duration),
+                TCSignificance=t.uint8_t(tc_significance),
+            ),
+            timeout=ZDO_TIMEOUT,
+        )
+        self._send_zdo_rsp(packet, zdo_hdr, res.StatusCode)
+
+    async def _IEEE_addr_req(
+            self,
+            packet: t.ZigbeePacket,
+            zdo_hdr: zdo_t.ZDOHeader,
+            zdo_args: tuple[Any]) -> None:
+        """Send ZDO IEEE addr request and handle the response."""
+        nwki, req_type, index = zdo_args
+        res = await self._api.request(
+            c.ZDO.IeeeAddrReq.Req(
+                TSN=zdo_hdr.tsn,
+                DstNWK=packet.dst.address,
+                NWKtoMatch=nwki,
+                RequestType=req_type,
+                StartIndex=index,
+                ),
+            timeout=ZDO_TIMEOUT,
+        )
+
+        if res.StatusCode:
+            # ZDO command failed, use dummy values.
+            ieee = t.EUI64([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
+            nwki = t.NWK(0xffff)
+            src_ad = t.NWK(0x0000)
+        else:
+            ieee = res.RemoteDevIEEE
+            nwki = res.RemoteDevNWK
+            src_ad = res.RemoteDevNWK
+
+        # This request is broadcast, so the reply comes from the device that
+        # matched it rather than from the packet's destination.
+        self._send_zdo_rsp(
+            packet,
+            zdo_hdr,
+            res.StatusCode,
+            ieee,
+            nwki,
+            src=t.AddrModeAddress(
+                addr_mode=t.AddrMode.NWK,
+                address=src_ad,
+            ),
+        )
+
+    _ZDO_PACKET_HANDLERS = {
+        zdo_t.ZDOCmd.IEEE_addr_req: _IEEE_addr_req,
+        zdo_t.ZDOCmd.Node_Desc_req: _node_desc_req,
+        zdo_t.ZDOCmd.Simple_Desc_req: _simple_desc_req,
+        zdo_t.ZDOCmd.Active_EP_req: _active_ep_req,
+        zdo_t.ZDOCmd.Bind_req: _bind_req,
+        zdo_t.ZDOCmd.Unbind_req: _unbind_req,
+        zdo_t.ZDOCmd.Mgmt_Lqi_req: _mgmt_lqi_req,
+        zdo_t.ZDOCmd.Mgmt_Leave_req: _mgmt_leave_req,
+        zdo_t.ZDOCmd.Mgmt_Permit_Joining_req: _mgmt_permit_joining_req,
+    }
+
+
+class ZbossDevice(zigpy.device.Device):
+    """Class representing an nRF device."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize instance."""
+        super().__init__(*args, **kwargs)
+        assert hasattr(self, "zdo")
+        self.zdo = ZbossZDO(self)
+        self.endpoints[0] = self.zdo
+
+
+class ZbossCoordinator(ZbossDevice):
+    """Zigpy Device representing the controller."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize instance."""
+        super().__init__(*args, **kwargs)
+
+    @property
+    def manufacturer(self):
+        """Return manufacturer."""
+        return "Nordic Semiconductor"
+
+    @property
+    def model(self):
+        """Return model."""
+        return "nRF52840"

{zigpy_zboss-2.0.2 → zigpy_zboss-2.0.4/zigpy_zboss.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-zboss
-Version: 2.0.2
+Version: 2.0.4
 Summary: A library for zigpy which communicates with Nordic nRF52 radios running ZBOSS NCP
 Author-email: Damien Kastner <damien.kastner@kardia.no>
 License: GPL-3.0

zigpy_zboss-2.0.2/zigpy_zboss/zigbee/device.py

@@ -1,331 +0,0 @@
-"""Zigbee device object."""
-import logging
-from typing import Any
-
-import zigpy.device
-import zigpy.endpoint
-import zigpy.types as t
-import zigpy.util
-from zigpy.zdo import ZDO as ZigpyZDO
-from zigpy.zdo import types as zdo_t
-
-import zigpy_zboss.types as t_zboss
-from zigpy_zboss import commands as c
-
-LOGGER = logging.getLogger(__name__)
-
-
-class ZbossZDO(ZigpyZDO):
-    """The ZDO endpoint of a ZBOSS device."""
-
-    def handle_mgmt_permit_joining_req(
-        self,
-        permit_duration: int,
-        tc_significance: int,
-    ):
-        """Handle ZDO permit joining request."""
-        hdr = zdo_t.ZDOHeader(zdo_t.ZDOCmd.Mgmt_Permit_Joining_req, 0)
-        dst_addressing = t.Addressing.IEEE
-
-        self.listener_event("permit_duration", permit_duration)
-        self.listener_event(
-            "zdo_mgmt_permit_joining_req",
-            self._device,
-            dst_addressing,
-            hdr,
-            (permit_duration, tc_significance),
-        )
-
-    async def Bind_req(self, eui64, ep, cluster, dst_address):
-        """Binding request."""
-        if dst_address.addrmode == t.AddrMode.IEEE:
-            addr_mode = t_zboss.BindAddrMode.IEEE
-            dst_eui64 = dst_address.ieee
-        # ZBOSS does not support the NWK mode for binding
-        elif dst_address.addrmode == t.AddrMode.NWK:
-            self.log(
-                logging.WARNING,
-                "Nwk address mode is not supported for the Bind request."
-            )
-        elif dst_address.addrmode == t.AddrMode.Group:
-            addr_mode = t_zboss.BindAddrMode.Group
-            dst_eui64 = [
-                dst_address.nwk % 0x100,
-                dst_address.nwk >> 8,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-            ]
-
-        res = await self._device._application._api.request(
-            c.ZDO.BindReq.Req(
-                TSN=self._device._application.get_sequence(),
-                TargetNwkAddr=self._device.nwk,
-                SrcIEEE=eui64,
-                SrcEndpoint=ep,
-                ClusterId=cluster,
-                DstAddrMode=addr_mode,
-                DstAddr=dst_eui64,
-                DstEndpoint=dst_address.endpoint,
-            )
-        )
-        if res.StatusCode != 0:
-            return (res.StatusCode % 0xFF, dst_address, cluster)
-
-        return (zdo_t.Status.SUCCESS, dst_address, cluster)
-
-    async def Unbind_req(self, eui64, ep, cluster, dst_address):
-        """Unbinding request."""
-        if dst_address.addrmode == t.AddrMode.IEEE:
-            addr_mode = t_zboss.BindAddrMode.IEEE
-            dst_eui64 = t.Addressing.IEEE
-        # ZBOSS does not support the NWK mode for binding
-        elif dst_address.addrmode == t.AddrMode.NWK:
-            self.log(
-                logging.WARNING,
-                "Nwk address mode is not supported for the Unbind request."
-            )
-        elif dst_address.addrmode == t.AddrMode.Group:
-            addr_mode = t_zboss.BindAddrMode.Group
-            dst_eui64 = [
-                dst_address.nwk % 0x100,
-                dst_address.nwk >> 8,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-            ]
-
-        res = await self._device._application._api.request(
-            c.ZDO.UnbindReq.Req(
-                TSN=self._device._application.get_sequence(),
-                TargetNwkAddr=self._device.nwk,
-                SrcIEEE=eui64,
-                SrcEndpoint=ep,
-                ClusterId=cluster,
-                DstAddrMode=addr_mode,
-                DstAddr=dst_eui64,
-                DstEndpoint=dst_address.endpoint,
-            )
-        )
-        if res.StatusCode != 0:
-            return (res.StatusCode % 0xFF, dst_address, cluster)
-
-        return (zdo_t.Status.SUCCESS, dst_address, cluster)
-
-    def request(self, command, *args, use_ieee=False):
-        """Request overwrite for Bind/Unbind requests."""
-        if command == zdo_t.ZDOCmd.Bind_req:
-            return self.Bind_req(*args)
-        if command == zdo_t.ZDOCmd.Unbind_req:
-            return self.Unbind_req(*args)
-        return super().request(command, *args, use_ieee=use_ieee)
-
-    async def Node_Desc_req(self, nwk):
-        """Node descriptor request."""
-        res = await self._device._application._api.request(
-            c.ZDO.NodeDescReq.Req(
-                TSN=self._device._application.get_sequence(),
-                NwkAddr=nwk
-            )
-        )
-        if res.StatusCode != 0:
-            return (res.StatusCode, None, None)
-
-        return (zdo_t.Status.SUCCESS, None, res.NodeDesc)
-
-    async def Simple_Desc_req(self, nwk, ep):
-        """Request simple descriptor."""
-        res = await self._device._application._api.request(
-            c.ZDO.SimpleDescriptorReq.Req(
-                TSN=self._device._application.get_sequence(),
-                NwkAddr=nwk,
-                Endpoint=ep
-            )
-        )
-        if res.StatusCode != 0:
-            return (res.StatusCode, None, None)
-
-        desc = zdo_t.SimpleDescriptor(
-            endpoint=res.SimpleDesc.endpoint,
-            profile=res.SimpleDesc.profile,
-            device_type=res.SimpleDesc.device_type,
-            device_version=res.SimpleDesc.device_version,
-            input_clusters=res.SimpleDesc.input_clusters,
-            output_clusters=res.SimpleDesc.output_clusters,
-        )
-
-        return (zdo_t.Status.SUCCESS, None, desc)
-
-    async def Active_EP_req(self, nwk):
-        """Request active end points."""
-        res = await self._device._application._api.request(
-            c.ZDO.ActiveEpReq.Req(
-                TSN=self._device._application.get_sequence(),
-                NwkAddr=nwk
-            )
-        )
-        if res.StatusCode != 0:
-            return (res.StatusCode, None, None)
-
-        return (zdo_t.Status.SUCCESS, None, res.ActiveEpList)
-
-    async def Mgmt_Lqi_req(self, idx):
-        """Request Link Quality Index."""
-        res = await self._device._application._api.request(
-            c.ZDO.MgmtLqi.Req(
-                TSN=self._device._application.get_sequence(),
-                DestNWK=self._device.nwk,
-                Index=idx,
-            )
-        )
-        if res.StatusCode != 0:
-            return (res.StatusCode, None)
-
-        return (res.StatusCode, res.Neighbors)
-
-    async def Mgmt_Leave_req(self, ieee, flags):
-        """Request device leaving the network."""
-        res = await self._device._application._api.request(
-            c.ZDO.MgtLeave.Req(
-                TSN=self._device._application.get_sequence(),
-                DestNWK=t.NWK(self._device._application.devices[ieee].nwk),
-                IEEE=t.EUI64(ieee),
-                Flags=t.uint8_t(flags),
-            )
-        )
-        return res.StatusCode
-
-    async def Mgmt_Permit_Joining_req(self, duration, tc_significance):
-        """Request join permition."""
-        res = await self._device._application._api.request(
-            c.ZDO.PermitJoin.Req(
-                TSN=self._device._application.get_sequence(),
-                DestNWK=t.NWK(t.BroadcastAddress.RX_ON_WHEN_IDLE),
-                PermitDuration=t.uint8_t(duration),
-                TCSignificance=t.uint8_t(tc_significance),
-            )
-        )
-        return res.StatusCode
-
-    async def Mgmt_NWK_Update_req(self, nwkUpdate):
-        """Issue a ZDO Mgmt_NWK_Update (energy scan / channel change)."""
-        res = await self._device._application._api.request(
-            c.ZDO.MgmtNwkUpdate.Req(
-                TSN=self._device._application.get_sequence(),
-                ScanChannelMask=nwkUpdate.ScanChannels,
-                ScanDuration=nwkUpdate.ScanDuration,
-                ScanCount=nwkUpdate.ScanCount or 0,
-                MgrAddr=self._device.nwk,
-                DstNWK=t.NWK(0x0000),
-            )
-        )
-        if res.StatusCode != 0:
-            raise zigpy.exceptions.DeliveryError(
-                f"Mgmt_NWK_Update_req failed: {res.StatusCode}",
-                status=res.StatusCode,
-            )
-        return (None, res.ScannedChannels, None, None, res.EnergyValues)
-
-    async def zboss_specific_cmd(self, packet: t.ZigbeePacket) -> None:
-        """Reroute ZDO packet sent over APSDE to custom ZBOSS ZDO commands."""
-        try:
-            zdo_hdr, zdo_args = self.deserialize(
-                cluster_id=packet.cluster_id, data=packet.data.serialize()
-            )
-        except ValueError:
-            LOGGER.debug("Could not parse ZDO message from packet")
-            return
-
-        if zdo_hdr.command_id == zdo_t.ZDOCmd.IEEE_addr_req:
-            await self._IEEE_addr_req(packet, zdo_hdr, zdo_args)
-
-    async def _IEEE_addr_req(
-            self,
-            packet: t.ZigbeePacket,
-            zdo_hdr: zdo_t.ZDOHeader,
-            zdo_args: tuple[Any]) -> None:
-        """Send ZDO IEEE addr request and handle the response."""
-        tsn = zdo_hdr.tsn
-        nwki, req_type, index = zdo_args
-        res = await self._device._application._api.request(
-            c.ZDO.IeeeAddrReq.Req(
-                TSN=tsn,
-                DstNWK=packet.dst.address,
-                NWKtoMatch=nwki,
-                RequestType=req_type,
-                StartIndex=index,
-                ),
-            timeout=70,
-        )
-
-        if res.StatusCode:
-            # ZDO command failed, use dummy values.
-            ieee = t.EUI64([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
-            nwki = t.NWK(0xffff)
-            src_ad = t.NWK(0x0000)
-        else:
-            ieee = res.RemoteDevIEEE
-            nwki = res.RemoteDevNWK
-            src_ad = res.RemoteDevNWK
-
-        status = zdo_t.Status(res.StatusCode)
-        data = tsn.serialize() \
-            + status.serialize() \
-            + ieee.serialize() \
-            + nwki.serialize()
-
-        packet = t.ZigbeePacket(
-            src=t.AddrModeAddress(
-                addr_mode=t.AddrMode.NWK,
-                address=src_ad,
-            ),
-            src_ep=0,
-            dst=t.AddrModeAddress(
-                addr_mode=t.AddrMode.NWK,
-                address=t.NWK(0x0000),
-            ),
-            dst_ep=0,
-            tsn=tsn,
-            profile_id=0,
-            cluster_id=zdo_t.ZDOCmd.IEEE_addr_rsp,
-            data=t.SerializableBytes(data),
-            tx_options=t.TransmitOptions.NONE,
-            lqi=None,
-            rssi=None
-        )
-        self._device._application.packet_received(packet)
-
-
-class ZbossDevice(zigpy.device.Device):
-    """Class representing an nRF device."""
-
-    def __init__(self, *args, **kwargs):
-        """Initialize instance."""
-        super().__init__(*args, **kwargs)
-        assert hasattr(self, "zdo")
-        self.zdo = ZbossZDO(self)
-        self.endpoints[0] = self.zdo
-
-
-class ZbossCoordinator(ZbossDevice):
-    """Zigpy Device representing the controller."""
-
-    def __init__(self, *args, **kwargs):
-        """Initialize instance."""
-        super().__init__(*args, **kwargs)
-
-    @property
-    def manufacturer(self):
-        """Return manufacturer."""
-        return "Nordic Semiconductor"
-
-    @property
-    def model(self):
-        """Return model."""
-        return "nRF52840"