[Python] Update AttributeRead (#11575)

src/controller/python/BUILD.gn

@@ -45,8 +45,8 @@ shared_library("ChipDeviceCtrl") {
     "ChipDeviceController-StorageDelegate.cpp",
     "ChipDeviceController-StorageDelegate.h",
     "chip/clusters/CHIPClusters.cpp",
+    "chip/clusters/attribute.cpp",
     "chip/clusters/command.cpp",
-    "chip/clusters/write.cpp",
     "chip/discovery/NodeResolution.cpp",
     "chip/interaction_model/Delegate.cpp",
     "chip/interaction_model/Delegate.h",

src/controller/python/chip/ChipDeviceCtrl.py

@@ -378,37 +378,54 @@ def WriteAttribute(self, nodeid: int, attributes):
             raise self._ChipStack.ErrorToException(res)
         return future
 
-    def ReadAttribute(self, nodeid: int, attributes: typing.List[typing.Tuple[int, ClusterAttribute.AttributeReadRequest]]):
+    def ReadAttribute(self, nodeid: int, attributes: typing.List[typing.Union[
+        None,  # Empty tuple, all wildcard
+        typing.Tuple[int],  # Endpoint
+        # Wildcard endpoint, Cluster id present
+        typing.Tuple[typing.Type[ClusterObjects.Cluster]],
+        # Wildcard endpoint, Cluster + Attribute present
+        typing.Tuple[typing.Type[ClusterObjects.ClusterAttributeDescriptor]],
+        # Wildcard attribute id
+        typing.Tuple[int, typing.Type[ClusterObjects.Cluster]],
+        # Concrete path
+        typing.Tuple[int, typing.Type[ClusterObjects.ClusterAttributeDescriptor]]
+    ]]):
         eventLoop = asyncio.get_running_loop()
         future = eventLoop.create_future()
 
         device = self.GetConnectedDeviceSync(nodeid)
-        # TODO: Here, we translates multi attribute read into many individual attribute reads, this should be fixed by implementing Python's attribute read API.
-        res = []
-        for attr in attributes:
-            endpointId = attr[0]
-            attribute = attr[1]
-            clusterInfo = self._Cluster.GetClusterInfoById(
-                attribute.cluster_id)
-            if not clusterInfo:
-                raise UnknownCluster(attribute.cluster_id)
-            attributeInfo = clusterInfo.get("attributes", {}).get(
-                attribute.attribute_id, None)
-            if not attributeInfo:
-                raise UnknownAttribute(
-                    clusterInfo["clusterName"], attribute.attribute_id)
-            self._Cluster.ReadAttribute(
-                device, clusterInfo["clusterName"], attributeInfo["attributeName"], endpointId, 0, False)
-            readRes = im.GetAttributeReadResponse(
-                im.DEFAULT_ATTRIBUTEREAD_APPID)
-            res.append(ClusterAttribute.AttributeReadResult(
-                Path=ClusterAttribute.AttributePath(
-                    EndpointId=endpointId, ClusterId=attribute.cluster_id, AttributeId=attribute.attribute_id),
-                Status=readRes.status,
-                Data=(attribute.FromTagDictOrRawValue(
-                    readRes.value) if readRes.value is not None else None),
-            ))
-        future.set_result(res)
+        attrs = []
+        for v in attributes:
+            endpoint = None
+            cluster = None
+            attribute = None
+            if v == () or v == ('*'):
+                # Wildcard
+                pass
+            elif len(v) == 1:
+                if v[0] is int:
+                    endpoint = v[0]
+                elif issubclass(v[0], ClusterObjects.Cluster):
+                    cluster = v[0]
+                elif issubclass(v[0], ClusterObjects.ClusterAttributeDescriptor):
+                    attribute = v[0]
+                else:
+                    raise ValueError("Unsupported Attribute Path")
+            elif len(v) == 2:
+                # endpoint + (cluster) attribute / endpoint + cluster
+                endpoint = v[0]
+                if issubclass(v[1], ClusterObjects.Cluster):
+                    cluster = v[1]
+                elif issubclass(v[1], ClusterAttribute.ClusterAttributeDescriptor):
+                    attribute = v[1]
+                else:
+                    raise ValueError("Unsupported Attribute Path")
+            attrs.append(ClusterAttribute.AttributePath(
+                EndpointId=endpoint, Cluster=cluster, Attribute=attribute))
+        res = self._ChipStack.Call(
+            lambda: ClusterAttribute.ReadAttributes(future, eventLoop, device, attrs))
+        if res != 0:
+            raise self._ChipStack.ErrorToException(res)
         return future
 
     def ZCLSend(self, cluster, command, nodeid, endpoint, groupid, args, blocking=False):

src/controller/python/chip/clusters/Attribute.py

@@ -24,13 +24,40 @@
 from .ClusterObjects import ClusterAttributeDescriptor
 import chip.exceptions
 import chip.interaction_model
+import chip.tlv
+
+import inspect
+import sys
+import logging
 
 
 @dataclass
 class AttributePath:
-    EndpointId: int
-    ClusterId: int
-    AttributeId: int
+    EndpointId: int = None
+    ClusterId: int = None
+    AttributeId: int = None
+
+    def __init__(self, EndpointId: int = None, Cluster=None, Attribute=None, ClusterId=None, AttributeId=None):
+        self.EndpointId = EndpointId
+        if Cluster is not None:
+            # Wildcard read for a specific cluster
+            if (Attribute is not None) or (ClusterId is not None) or (AttributeId is not None):
+                raise Warning(
+                    "Attribute, ClusterId and AttributeId is ignored when Cluster is specified")
+            self.ClusterId = Cluster.id
+            return
+        if Attribute is not None:
+            if (ClusterId is not None) or (AttributeId is not None):
+                raise Warning(
+                    "ClusterId and AttributeId is ignored when Attribute is specified")
+            self.ClusterId = Attribute.cluster_id
+            self.AttributeId = Attribute.attribute_id
+            return
+        self.ClusterId = ClusterId
+        self.AttributeId = AttributeId
+
+    def __str__(self) -> str:
+        return f"{self.EndpointId}/{self.ClusterId}/{self.AttributeId}"
 
 
 @dataclass
@@ -61,6 +88,72 @@ class AttributeReadResult(AttributeStatus):
     Data: Any = None
 
 
+_AttributeIndex = {}
+
+
+def _BuildAttributeIndex():
+    ''' Build internal attribute index for locating the corresponding cluster object by path in the future.
+    We do this because this operation will take a long time when there are lots of attributes, it takes about 300ms for a single query.
+    This is acceptable during init, but unacceptable when the server returns lots of attributes at the same time.
+    '''
+    for clusterName, obj in inspect.getmembers(sys.modules['chip.clusters.Objects']):
+        if ('chip.clusters.Objects' in str(obj)) and inspect.isclass(obj):
+            for objName, subclass in inspect.getmembers(obj):
+                if inspect.isclass(subclass) and (('Attribute') in str(subclass)):
+                    for attributeName, attribute in inspect.getmembers(subclass):
+                        if inspect.isclass(attribute):
+                            for name, field in inspect.getmembers(attribute):
+                                if ('__dataclass_fields__' in name):
+                                    _AttributeIndex[str(AttributePath(ClusterId=field['cluster_id'].default, AttributeId=field['attribute_id'].default))] = eval(
+                                        'chip.clusters.Objects.' + clusterName + '.Attributes.' + attributeName)
+
+
+class AsyncReadTransaction:
+    def __init__(self, future: Future, eventLoop):
+        self._event_loop = eventLoop
+        self._future = future
+        self._res = []
+
+    def _handleAttributeData(self, path: AttributePath, status: int, data: bytes):
+        try:
+            imStatus = status
+            try:
+                imStatus = chip.interaction_model.Status(status)
+            except:
+                pass
+            attributeType = _AttributeIndex.get(str(AttributePath(
+                ClusterId=path.ClusterId, AttributeId=path.AttributeId)), None)
+            attributeValue = None
+            if attributeType is None:
+                attributeValue = chip.tlv.TLVReader(data).get().get("Any", {})
+            else:
+                attributeValue = attributeType.FromTLV(data)
+            self._res.append(AttributeReadResult(
+                Path=path, Status=imStatus, Data=attributeValue))
+        except Exception as ex:
+            logging.exception(ex)
+
+    def handleAttributeData(self, path: AttributePath, status: int, data: bytes):
+        self._event_loop.call_soon_threadsafe(
+            self._handleAttributeData, path, status, data)
+
+    def _handleError(self, chipError: int):
+        self._future.set_exception(
+            chip.exceptions.ChipStackError(chipError))
+
+    def handleError(self, chipError: int):
+        self._event_loop.call_soon_threadsafe(
+            self._handleError, chipError
+        )
+
+    def _handleDone(self, asd):
+        if not self._future.done():
+            self._future.set_result(self._res)
+
+    def handleDone(self):
+        self._event_loop.call_soon_threadsafe(self._handleDone, "asdasa")
+
+
 class AsyncWriteTransaction:
     def __init__(self, future: Future, eventLoop):
         self._event_loop = eventLoop
@@ -95,6 +188,32 @@ def handleDone(self):
         self._event_loop.call_soon_threadsafe(self._handleDone)
 
 
+_OnReadAttributeDataCallbackFunct = CFUNCTYPE(
+    None, py_object, c_uint16, c_uint32, c_uint32, c_uint16, c_char_p, c_size_t)
+_OnReadErrorCallbackFunct = CFUNCTYPE(
+    None, py_object, c_uint32)
+_OnReadDoneCallbackFunct = CFUNCTYPE(
+    None, py_object)
+
+
+@_OnReadAttributeDataCallbackFunct
+def _OnReadAttributeDataCallback(closure, endpoint: int, cluster: int, attribute: int, status, data, len):
+    dataBytes = ctypes.string_at(data, len)
+    closure.handleAttributeData(AttributePath(
+        EndpointId=endpoint, ClusterId=cluster, AttributeId=attribute), status, dataBytes[:])
+
+
+@_OnReadErrorCallbackFunct
+def _OnReadErrorCallback(closure, chiperror: int):
+    closure.handleError(chiperror)
+
+
+@_OnReadDoneCallbackFunct
+def _OnReadDoneCallback(closure):
+    closure.handleDone()
+    ctypes.pythonapi.Py_DecRef(ctypes.py_object(closure))
+
+
 _OnWriteResponseCallbackFunct = CFUNCTYPE(
     None, py_object, c_uint16, c_uint32, c_uint32, c_uint16)
 _OnWriteErrorCallbackFunct = CFUNCTYPE(
@@ -105,7 +224,8 @@ def handleDone(self):
 
 @_OnWriteResponseCallbackFunct
 def _OnWriteResponseCallback(closure, endpoint: int, cluster: int, attribute: int, status):
-    closure.handleResponse(AttributePath(endpoint, cluster, attribute), status)
+    closure.handleResponse(AttributePath(
+        EndpointId=endpoint, ClusterId=cluster, AttributeId=attribute), status)
 
 
 @_OnWriteErrorCallbackFunct
@@ -144,6 +264,31 @@ def WriteAttributes(future: Future, eventLoop, device, attributes: List[Attribut
     return res
 
 
+def ReadAttributes(future: Future, eventLoop, device, attributes: List[AttributePath]) -> int:
+    handle = chip.native.GetLibraryHandle()
+    transaction = AsyncReadTransaction(future, eventLoop)
+
+    readargs = []
+    for attr in attributes:
+        path = chip.interaction_model.AttributePathIBstruct.parse(
+            b'\xff' * chip.interaction_model.AttributePathIBstruct.sizeof())
+        if attr.EndpointId is not None:
+            path.EndpointId = attr.EndpointId
+        if attr.ClusterId is not None:
+            path.ClusterId = attr.ClusterId
+        if attr.AttributeId is not None:
+            path.AttributeId = attr.AttributeId
+        path = chip.interaction_model.AttributePathIBstruct.build(path)
+        readargs.append(ctypes.c_char_p(path))
+
+    ctypes.pythonapi.Py_IncRef(ctypes.py_object(transaction))
+    res = handle.pychip_ReadClient_ReadAttributes(
+        ctypes.py_object(transaction), device, ctypes.c_size_t(len(attributes)), *readargs)
+    if res != 0:
+        ctypes.pythonapi.Py_DecRef(ctypes.py_object(transaction))
+    return res
+
+
 def Init():
     handle = chip.native.GetLibraryHandle()
 
@@ -155,6 +300,13 @@ def Init():
         handle.pychip_WriteClient_WriteAttributes.restype = c_uint32
         setter.Set('pychip_WriteClient_InitCallbacks', None, [
                    _OnWriteResponseCallbackFunct, _OnWriteErrorCallbackFunct, _OnWriteDoneCallbackFunct])
+        handle.pychip_ReadClient_ReadAttributes.restype = c_uint32
+        setter.Set('pychip_ReadClient_InitCallbacks', None, [
+                   _OnReadAttributeDataCallbackFunct, _OnReadErrorCallbackFunct, _OnReadDoneCallbackFunct])
 
     handle.pychip_WriteClient_InitCallbacks(
         _OnWriteResponseCallback, _OnWriteErrorCallback, _OnWriteDoneCallback)
+    handle.pychip_ReadClient_InitCallbacks(
+        _OnReadAttributeDataCallback, _OnReadErrorCallback, _OnReadDoneCallback)
+
+    _BuildAttributeIndex()

src/controller/python/chip/clusters/ClusterObjects.py

@@ -149,6 +149,13 @@ def command_id(self) -> int:
         raise NotImplementedError()
 
 
+class Cluster:
+    ''' This class does nothing, but a convenient class that generated clusters can inherit from.
+    This gives the ability that the users can use issubclass(X, Cluster) to determine if the class represnents a Cluster.
+    '''
+    pass
+
+
 class ClusterAttributeDescriptor:
     '''
     The ClusterAttributeDescriptor is used for holding an attribute's metadata like its cluster id, attribute id and its type.