Support zigpy 0.9

Author: doudz

setup.py

@@ -48,7 +48,7 @@ def is_raspberry_pi(raise_on_errors=False):
 
 
 requires = ['pyserial-asyncio',
-            'zigpy-homeassistant',  # https://github.com/zigpy/zigpy/issues/190
+            'zigpy-homeassistant>=0.9.0',  # https://github.com/zigpy/zigpy/issues/190
             ]
 if is_raspberry_pi():
     requires.append('RPi.GPIO')

zigpy_zigate/__init__.py

@@ -1,5 +1,5 @@
 MAJOR_VERSION = 0
-MINOR_VERSION = 3
-PATCH_VERSION = '1'
+MINOR_VERSION = 4
+PATCH_VERSION = '0'
 __short_version__ = '{}.{}'.format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = '{}.{}'.format(__short_version__, PATCH_VERSION)

zigpy_zigate/api.py

@@ -34,6 +34,10 @@
 }
 
 
+class NoResponseError(Exception):
+    pass
+
+
 class ZiGate:
     def __init__(self):
         self._uart = None
@@ -77,7 +81,7 @@ async def command(self, cmd, data=b'', wait_response=None, wait_status=True):
             )
         except asyncio.TimeoutError:
             LOGGER.warning("No response to command 0x{:04x}".format(cmd))
-            raise
+            raise NoResponseError
 
     def _command(self, cmd, data=b'', wait_response=None, wait_status=True):
         self._uart.send(cmd, data)

zigpy_zigate/zigbee/application.py

@@ -1,11 +1,11 @@
 import asyncio
 import logging
 
-from zigpy.exceptions import DeliveryError
 import zigpy.device
 import zigpy.application
 import zigpy.util
 from zigpy_zigate import types as t
+from zigpy_zigate.api import NoResponseError
 
 LOGGER = logging.getLogger(__name__)
 
@@ -18,7 +18,6 @@ def __init__(self, api, database_file=None):
         api.set_application(self)
 
         self._pending = {}
-        self._zigate_seq = {}
 
         self._nwk = 0
         self._ieee = 0
@@ -106,78 +105,48 @@ def zigate_callback_handler(self, msg, response, lqi):
                 return
             rssi = 0
             device.radio_details(lqi, rssi)
-            tsn, command_id, is_reply, args = self.deserialize(device, response[3],
-                                                               response[2], response[-1])
-            if is_reply:
-                self._handle_reply(device, response, tsn, command_id, args)
-            else:
-                self.handle_message(device, False, response[1],
-                                    response[2],
-                                    response[3], response[4],
-                                    tsn, command_id, args)
+            self.handle_message(device, response[1],
+                                response[2],
+                                response[3], response[4], response[-1])
         elif msg == 0x8702:  # APS Data confirm Fail
             self._handle_frame_failure(response[4], response[0])
 
-    def _handle_reply(self, sender, response, tsn, command_id, args):
-        try:
-            send_fut, reply_fut = self._pending[tsn]
-            if send_fut.done():
-                self._pending.pop(tsn)
-            if reply_fut:
-                reply_fut.set_result(args)
-            return
-        except KeyError:
-            LOGGER.warning("Unexpected response TSN=%s command=%s args=%s", tsn, command_id, args)
-        except asyncio.futures.InvalidStateError as exc:
-            LOGGER.debug("Invalid state on future - probably duplicate response: %s", exc)
-            # We've already handled, don't drop through to device handler
-            # EDIT : Temporary remove return since we can receive more that one reply with the same tsn
-            # return
-
-        self.handle_message(sender, True, response[1],
-                            response[2], response[3], response[4],
-                            tsn, command_id, args)
-
     def _handle_frame_failure(self, message_tag, status):
         try:
-            send_fut, reply_fut = self._pending.pop(message_tag)
-            send_fut.set_exception(DeliveryError("Message send failure: %s" % (status, )))
-            if reply_fut:
-                reply_fut.cancel()
+            send_fut = self._pending.pop(message_tag)
+            send_fut.set_result(status)
         except KeyError:
             LOGGER.warning("Unexpected message send failure")
         except asyncio.futures.InvalidStateError as exc:
             LOGGER.debug("Invalid state on future - probably duplicate response: %s", exc)
 
     @zigpy.util.retryable_request
-    async def request(self, nwk, profile, cluster, src_ep, dst_ep, sequence, data, expect_reply=True, timeout=10):
-        LOGGER.debug('request %s', (nwk, profile, cluster, src_ep, dst_ep, sequence, data, expect_reply, timeout))
-        assert sequence not in self._pending
+    async def request(self, device, profile, cluster, src_ep, dst_ep, sequence, data,
+                      expect_reply=True, use_ieee=False):
+        LOGGER.debug('request %s',
+                     (device.nwk, profile, cluster, src_ep, dst_ep, sequence, data, expect_reply, use_ieee))
+        req_id = self.get_sequence()
         send_fut = asyncio.Future()
-        reply_fut = None
-        if expect_reply:
-            reply_fut = asyncio.Future()
-        self._pending[sequence] = (send_fut, reply_fut)
-        v, lqi = await self._api.raw_aps_data_request(nwk, src_ep, dst_ep, profile, cluster, data)
-        self._zigate_seq[sequence] = v[1]
+        self._pending[req_id] = send_fut
+        try:
+            v, lqi = await self._api.raw_aps_data_request(device.nwk, src_ep, dst_ep, profile, cluster, data)
+        except NoResponseError:
+            return 1, "ZiGate doesn't answer to command"
 
         if v[0] != 0:
-            self._pending.pop(sequence)
-            self._zigate_seq.pop(sequence)
-            if expect_reply:
-                reply_fut.cancel()
-            raise DeliveryError("Message send failure %s" % (v[0], ))
-
-        if expect_reply:
-            # Wait for reply
-            try:
-                v = await asyncio.wait_for(reply_fut, timeout)
-            except:  # noqa: E722
-                # If we timeout (or fail for any reason), clear the future
-                self._pending.pop(sequence)
-                self._zigate_seq.pop(sequence)
-                raise
-        return v
+            self._pending.pop(req_id)
+            return v[0], "Message send failure %s"
+
+        # Commented out for now
+        # Currently (Firmware 3.1a) only send APS Data confirm in case of failure
+#         try:
+#             v = await asyncio.wait_for(send_fut, 120)
+#         except asyncio.TimeoutError:
+#             return 1, "timeout waiting for message %s send ACK" % (sequence, )
+#         finally:
+#             self._pending.pop(req_id)
+#         return v, "Message sent"
+        return 0, "Message sent"
 
     async def permit_ncp(self, time_s=60):
         assert 0 <= time_s <= 254