[Python] Add write and read API with cluster object support (#10949)

src/app/WriteClient.h

@@ -35,6 +35,7 @@
 #include <messaging/Flags.h>
 #include <protocols/Protocols.h>
 #include <system/SystemPacketBuffer.h>
+#include <system/TLVPacketBufferBackingStore.h>
 
 namespace chip {
 namespace app {

src/controller/python/BUILD.gn

@@ -46,6 +46,7 @@ shared_library("ChipDeviceCtrl") {
     "ChipDeviceController-StorageDelegate.h",
     "chip/clusters/CHIPClusters.cpp",
     "chip/clusters/command.cpp",
+    "chip/clusters/write.cpp",
     "chip/discovery/NodeResolution.cpp",
     "chip/interaction_model/Delegate.cpp",
     "chip/interaction_model/Delegate.h",
@@ -111,6 +112,7 @@ pw_python_action("python") {
         "chip/ble/library_handle.py",
         "chip/ble/scan_devices.py",
         "chip/ble/types.py",
+        "chip/clusters/Attribute.py",
         "chip/clusters/CHIPClusters.py",
         "chip/clusters/ClusterObjects.py",
         "chip/clusters/Command.py",

src/controller/python/chip/ChipDeviceCtrl.py

@@ -30,13 +30,15 @@
 import asyncio
 from ctypes import *
 from .ChipStack import *
-from .clusters.CHIPClusters import *
 from .interaction_model import delegate as im
 from .exceptions import *
 from .clusters import Command as ClusterCommand
+from .clusters import Attribute as ClusterAttribute
 from .clusters import ClusterObjects as ClusterObjects
+from .clusters.CHIPClusters import *
 import enum
 import threading
+import typing
 
 
 __all__ = ["ChipDeviceController"]
@@ -134,6 +136,7 @@ def HandleCommissioningComplete(nodeid, err):
 
         im.InitIMDelegate()
         ClusterCommand.Init(self)
+        ClusterAttribute.Init()
 
         self.cbHandleKeyExchangeCompleteFunct = _DevicePairingDelegate_OnPairingCompleteFunct(
             HandleKeyExchangeComplete)
@@ -362,6 +365,52 @@ async def SendCommand(self, nodeid: int, endpoint: int, payload: ClusterObjects.
             future.set_exception(self._ChipStack.ErrorToException(res))
         return await future
 
+    def WriteAttribute(self, nodeid: int, attributes):
+        eventLoop = asyncio.get_running_loop()
+        future = eventLoop.create_future()
+
+        device = self.GetConnectedDeviceSync(nodeid)
+        res = self._ChipStack.Call(
+            lambda: ClusterAttribute.WriteAttributes(
+                future, eventLoop, device, attributes)
+        )
+        if res != 0:
+            raise self._ChipStack.ErrorToException(res)
+        return future
+
+    def ReadAttribute(self, nodeid: int, attributes: typing.List[typing.Tuple[int, ClusterAttribute.AttributeReadRequest]]):
+        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)
+        return future
+
     def ZCLSend(self, cluster, command, nodeid, endpoint, groupid, args, blocking=False):
         device = self.GetConnectedDeviceSync(nodeid)
 

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

@@ -0,0 +1,160 @@
+#
+#    Copyright (c) 2021 Project CHIP Authors
+#    All rights reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+from asyncio.futures import Future
+import ctypes
+from dataclasses import dataclass
+from typing import Type, Union, List, Any
+from ctypes import CFUNCTYPE, c_char_p, c_size_t, c_void_p, c_uint32,  c_uint16, py_object
+
+from .ClusterObjects import ClusterAttributeDescriptor
+import chip.exceptions
+import chip.interaction_model
+
+
+@dataclass
+class AttributePath:
+    EndpointId: int
+    ClusterId: int
+    AttributeId: int
+
+
+@dataclass
+class AttributeStatus:
+    Path: AttributePath
+    Status: Union[chip.interaction_model.Status, int]
+
+
+AttributeWriteResult = AttributeStatus
+
+
+@dataclass
+class AttributeDescriptorWithEndpoint:
+    EndpointId: int
+    Attribute: ClusterAttributeDescriptor
+
+
+@dataclass
+class AttributeWriteRequest(AttributeDescriptorWithEndpoint):
+    Data: Any
+
+
+AttributeReadRequest = AttributeDescriptorWithEndpoint
+
+
+@dataclass
+class AttributeReadResult(AttributeStatus):
+    Data: Any = None
+
+
+class AsyncWriteTransaction:
+    def __init__(self, future: Future, eventLoop):
+        self._event_loop = eventLoop
+        self._future = future
+        self._res = []
+
+    def _handleResponse(self, path: AttributePath, status: int):
+        try:
+            imStatus = chip.interaction_model.Status(status)
+            self._res.append(AttributeWriteResult(Path=path, Status=imStatus))
+        except:
+            self._res.append(AttributeWriteResult(Path=path, Status=status))
+
+    def handleResponse(self, path: AttributePath, status: int):
+        self._event_loop.call_soon_threadsafe(
+            self._handleResponse, path, status)
+
+    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):
+        if not self._future.done():
+            self._future.set_result(self._res)
+
+    def handleDone(self):
+        self._event_loop.call_soon_threadsafe(self._handleDone)
+
+
+_OnWriteResponseCallbackFunct = CFUNCTYPE(
+    None, py_object, c_uint16, c_uint32, c_uint32, c_uint16)
+_OnWriteErrorCallbackFunct = CFUNCTYPE(
+    None, py_object, c_uint32)
+_OnWriteDoneCallbackFunct = CFUNCTYPE(
+    None, py_object)
+
+
+@_OnWriteResponseCallbackFunct
+def _OnWriteResponseCallback(closure, endpoint: int, cluster: int, attribute: int, status):
+    closure.handleResponse(AttributePath(endpoint, cluster, attribute), status)
+
+
+@_OnWriteErrorCallbackFunct
+def _OnWriteErrorCallback(closure, chiperror: int):
+    closure.handleError(chiperror)
+
+
+@_OnWriteDoneCallbackFunct
+def _OnWriteDoneCallback(closure):
+    closure.handleDone()
+    ctypes.pythonapi.Py_DecRef(ctypes.py_object(closure))
+
+
+def WriteAttributes(future: Future, eventLoop, device, attributes: List[AttributeWriteRequest]) -> int:
+    handle = chip.native.GetLibraryHandle()
+    transaction = AsyncWriteTransaction(future, eventLoop)
+
+    writeargs = []
+    for attr in attributes:
+        path = chip.interaction_model.AttributePathStruct.parse(
+            b'\x00' * chip.interaction_model.AttributePathStruct.sizeof())
+        path.EndpointId = attr.EndpointId
+        path.ClusterId = attr.Attribute.cluster_id
+        path.AttributeId = attr.Attribute.attribute_id
+        path = chip.interaction_model.AttributePathStruct.build(path)
+        tlv = attr.Attribute.ToTLV(None, attr.Data)
+        writeargs.append(ctypes.c_char_p(path))
+        writeargs.append(ctypes.c_char_p(bytes(tlv)))
+        writeargs.append(ctypes.c_int(len(tlv)))
+
+    ctypes.pythonapi.Py_IncRef(ctypes.py_object(transaction))
+    res = handle.pychip_WriteClient_WriteAttributes(
+        ctypes.py_object(transaction), device, ctypes.c_size_t(len(attributes)), *writeargs)
+    if res != 0:
+        ctypes.pythonapi.Py_DecRef(ctypes.py_object(transaction))
+    return res
+
+
+def Init():
+    handle = chip.native.GetLibraryHandle()
+
+    # Uses one of the type decorators as an indicator for everything being
+    # initialized.
+    if not handle.pychip_WriteClient_InitCallbacks.argtypes:
+        setter = chip.native.NativeLibraryHandleMethodArguments(handle)
+
+        handle.pychip_WriteClient_WriteAttributes.restype = c_uint32
+        setter.Set('pychip_WriteClient_InitCallbacks', None, [
+                   _OnWriteResponseCallbackFunct, _OnWriteErrorCallbackFunct, _OnWriteDoneCallbackFunct])
+
+    handle.pychip_WriteClient_InitCallbacks(
+        _OnWriteResponseCallback, _OnWriteErrorCallback, _OnWriteDoneCallback)

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

@@ -170,6 +170,11 @@ def FromTLV(cls, tlvBuffer: bytes):
         obj_class = cls._cluster_object
         return obj_class.FromDict(obj_class.descriptor.TagDictToLabelDict('', {0: tlv.TLVReader(tlvBuffer).get().get('Any', {})})).Value
 
+    @classmethod
+    def FromTagDictOrRawValue(cls, val: Any):
+        obj_class = cls._cluster_object
+        return obj_class.FromDict(obj_class.descriptor.TagDictToLabelDict('', {0: val})).Value
+
     @ChipUtility.classproperty
     def cluster_id(self) -> int:
         raise NotImplementedError()

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

@@ -22,4 +22,6 @@
 
 """Provides Python APIs for CHIP."""
 from . import Command
+from . import Attribute
 from .Objects import *
+from . import CHIPClusters