DLMS-SPODES-client 0.19.12__py3-none-any.whl → 0.19.14__py3-none-any.whl

DLMS_SPODES_client/client.py

@@ -14,6 +14,7 @@ import datetime
 import os
 import hashlib
 from Cryptodome.Cipher import AES
+from StructResult import result
 from DLMS_SPODES_communications import Network, Serial, RS485, BLEKPZ, base
 from DLMS_SPODES.cosem_interface_classes import overview
 from DLMS_SPODES.cosem_interface_classes.collection import Collection, InterfaceClass, ic, cdt, ut, Data, AssociationLN
@@ -192,9 +193,6 @@ class Client:
         self.connection_time_release = 10
         """ number of second for port release after inactivity """
 
-        self.reply = GXReplyData()
-        """ use gurux reply class now """
-
         self.received_frames = deque()
         """ HDLC frames container from server """
 
@@ -261,19 +259,19 @@ class Client:
             case BLEKPZ():  return 3
             case _:         raise ValueError(F"can't calculate channel index by media: {self.media}")
 
-    def get_frame(self, read_data: bytearray) -> frame.Frame | None:
+    def get_frame(self, read_data: bytearray, reply: GXReplyData) -> frame.Frame | None:
         while len(read_data) != 0:
             new_frame = frame.Frame.try_from(read_data)
-            self.reply.complete = True
+            reply.complete = True
             if new_frame is None:
-                self.reply.complete = False
+                reply.complete = False
                 return None
             if new_frame.is_for_me(self.DA, self.SA):
                 self.received_frames.append(new_frame)
                 if new_frame.is_segmentation:
-                    self.reply.moreData |= RequestTypes.FRAME
+                    reply.moreData |= RequestTypes.FRAME
                 else:
-                    self.reply.moreData &= ~RequestTypes.FRAME
+                    reply.moreData &= ~RequestTypes.FRAME
                 # check control TODO: rewrite it
                 if new_frame.control.is_unnumbered():
                     if new_frame.control in (frame.Control.UA_F, frame.Control.SNRM_P):
@@ -306,234 +304,244 @@ class Client:
                 self.log(logL.WARN, F"ALIEN frame {new_frame}, expect with SA:{self.SA}")
                 # FROM GURUX - if new_frame.control == frame.Control.UI_PF:  # search next frame in read_data
 
-    def handleGbt(self):
-        index = self.reply.data.position - 1
-        self.reply.windowSize = self.settings.windowSize
-        bc = self.reply.data.getUInt8()
-        self.reply.streaming = (bc & 0x40) != 0
+    def handleGbt(self, reply: GXReplyData) -> result.Ok | result.Error:
+        index = reply.data.position - 1
+        reply.windowSize = self.settings.windowSize
+        bc = reply.data.getUInt8()
+        reply.streaming = (bc & 0x40) != 0
         windowSize = int(bc & 0x3F)
-        bn = self.reply.data.getUInt16()
-        bna = self.reply.data.getUInt16()
-        self.reply.blockNumber = bn
-        self.reply.blockNumberAck = bna
-        self.settings.blockNumberAck = self.reply.blockNumber
-        self.reply.command = None
-        len_ = _GXCommon.getObjectCount(self.reply.data)
-        if len_ > self.reply.data.size - self.reply.data.position:
-            self.reply.complete = False
+        bn = reply.data.getUInt16()
+        bna = reply.data.getUInt16()
+        reply.blockNumber = bn
+        reply.blockNumberAck = bna
+        self.settings.blockNumberAck = reply.blockNumber
+        reply.command = None
+        len_ = _GXCommon.getObjectCount(reply.data)
+        if len_ > reply.data.size - reply.data.position:
+            reply.complete = False
             return
-        GXDLMS.getDataFromBlock(self.reply.data, index)
+        GXDLMS.getDataFromBlock(reply.data, index)
         if (bc & 0x80) == 0:
-            self.reply.moreData = (RequestTypes(self.reply.moreData | RequestTypes.GBT))
+            reply.moreData = (RequestTypes(reply.moreData | RequestTypes.GBT))
         else:
-            self.reply.moreData = (RequestTypes(self.reply.moreData & ~RequestTypes.GBT))
-            if self.reply.data.size != 0:
-                self.reply.data.position = 0
-                self.getPdu()
-            # if self.reply.data.position != self.reply.data.size and (self.reply.command == XDLMSAPDU.READ_RESPONSE or self.reply.command == XDLMSAPDU.GET_RESPONSE) and (self.reply.moreData == RequestTypes.NONE or self.reply.peek):
-            #     self.reply.data.position = 0
-                # cls.getValueFromData(settings, self.reply)
-
-    def getPdu(self) -> Any:
+            reply.moreData = (RequestTypes(reply.moreData & ~RequestTypes.GBT))
+            if reply.data.size != 0:
+                reply.data.position = 0
+                if isinstance(res_pdu := self.getPdu(), result.Error):
+                    return res_pdu.with_msg("handle GBT")
+            # if reply.data.position != reply.data.size and (reply.command == XDLMSAPDU.READ_RESPONSE or reply.command == XDLMSAPDU.GET_RESPONSE) and (reply.moreData == RequestTypes.NONE or reply.peek):
+            #     reply.data.position = 0
+                # cls.getValueFromData(settings, reply)
+        return result.OK
+
+    def getPdu(self, reply: GXReplyData) -> result.Ok | result.Error:
         # TODO: make return pdu
-        if self.reply.command is None:
-            if self.reply.data.size - self.reply.data.position == 0:
-                raise ValueError("Invalid PDU")
-            index = self.reply.data.position
-            self.reply.command = XDLMSAPDU(self.reply.data.getUInt8())
-            match self.reply.command:
+        if reply.command is None:
+            if reply.data.size - reply.data.position == 0:
+                return result.Error(ValueError("Invalid PDU"), "getpdu")
+            index = reply.data.position
+            reply.command = XDLMSAPDU(reply.data.getUInt8())
+            match reply.command:
                 case XDLMSAPDU.GET_RESPONSE:
-                    response_type: int = self.reply.data.getUInt8()
-                    invoke_id_and_priority = self.reply.data.getUInt8()  # TODO: matching with setting params
+                    response_type: int = reply.data.getUInt8()
+                    invoke_id_and_priority = reply.data.getUInt8()  # TODO: matching with setting params
                     match response_type:
                         case pdu.GetResponse.NORMAL:
-                            match self.reply.data.getUInt8():  # Get-Data-Result[0]
-                                case 0:    GXDLMS.getDataFromBlock(self.reply.data, 0)
+                            match reply.data.getUInt8():  # Get-Data-Result[0]
+                                case 0:
+                                    GXDLMS.getDataFromBlock(reply.data, 0)
                                 case 1:
-                                    self.reply.error = pdu.DataAccessResult(self.reply.data.getUInt8())
-                                    if self.reply.error != 0:
-                                        raise exc.ResultError(self.reply.error)
-                                case err:  raise ValueError(F'Got Get-Data-Result[0] {err}, expect 0 or 1')
-                            GXDLMS.getDataFromBlock(self.reply.data, 0)
+                                    reply.error = pdu.DataAccessResult(reply.data.getUInt8())
+                                    if reply.error != 0:
+                                        return result.Error.from_e(exc.ResultError(reply.error), "get pdu")
+                                case err:
+                                    return result.Error.from_e(ValueError(F'Got Get-Data-Result[0] {err}, expect 0 or 1'), "get pdu")
+                            GXDLMS.getDataFromBlock(reply.data, 0)
                         case pdu.GetResponse.WITH_DATABLOCK:
-                            last_block = self.reply.data.getUInt8()
+                            last_block = reply.data.getUInt8()
                             if last_block == 0:
-                                self.reply.moreData |= RequestTypes.DATABLOCK
+                                reply.moreData |= RequestTypes.DATABLOCK
                             else:
-                                self.reply.moreData &= ~RequestTypes.DATABLOCK
-                            block_number = self.reply.data.getUInt32()
+                                reply.moreData &= ~RequestTypes.DATABLOCK
+                            block_number = reply.data.getUInt32()
                             if block_number == 0 and self.settings.blockIndex == 1:  # if start block_index == 0
                                 self.settings.setBlockIndex(0)
                             if block_number != self.settings.blockIndex:
-                                raise ValueError(F"Invalid Block number. It is {block_number} and it should be {self.settings.blockIndex}.")
-                            match self.reply.data.getUInt8():  # DataBlock-G.result
+                                return result.Error.from_e(ValueError(F"Invalid Block number. It is {block_number} and it should be {self.settings.blockIndex}."), "get pdu")
+                            match reply.data.getUInt8():  # DataBlock-G.result,
                                 case 0:
-                                    if self.reply.data.position != len(self.reply.data):
-                                        block_length = _GXCommon.getObjectCount(self.reply.data)
-                                        if (self.reply.moreData & RequestTypes.FRAME) == 0:
-                                            if block_length > len(self.reply.data) - self.reply.data.position:
-                                                raise ValueError("Invalid block length.")
-                                            self.reply.command = None
+                                    if reply.data.position != len(reply.data):
+                                        block_length = _GXCommon.getObjectCount(reply.data)
+                                        if (reply.moreData & RequestTypes.FRAME) == 0:
+                                            if block_length > len(reply.data) - reply.data.position:
+                                                return result.Error.from_e(ValueError("Invalid block length."), "get pdu")
+                                            reply.command = None
                                         if block_length == 0:
-                                            self.reply.data.size = index
+                                            reply.data.size = index
                                         else:
-                                            GXDLMS.getDataFromBlock(self.reply.data, index)
-                                        if self.reply.moreData == RequestTypes.NONE:
-                                            if not self.reply.peek:
-                                                self.reply.data.position = 0
+                                            GXDLMS.getDataFromBlock(reply.data, index)
+                                        if reply.moreData == RequestTypes.NONE:
+                                            if not reply.peek:
+                                                reply.data.position = 0
                                                 self.settings.resetBlockIndex()
-                                        if self.reply.moreData == RequestTypes.NONE and self.settings and self.settings.command == XDLMSAPDU.GET_REQUEST \
+                                        if reply.moreData == RequestTypes.NONE and self.settings and self.settings.command == XDLMSAPDU.GET_REQUEST \
                                                 and self.settings.commandType == pdu.GetResponse.WITH_LIST:
-                                            GXDLMS.handleGetResponseWithList(self.settings, self.reply)
-                                            return
+                                            GXDLMS.handleGetResponseWithList(self.settings, reply)
+                                            return result.OK
                                 case 1:
-                                    self.reply.error = pdu.DataAccessResult(self.reply.data.getUInt8())
-                                    if self.reply.error != 0:
-                                        raise exc.ResultError(self.reply.error)
-                                case err: raise ValueError(F'Got DataBlock-G.result {err}, expect 0 or 1')
+                                    reply.error = pdu.DataAccessResult(reply.data.getUInt8())
+                                    if reply.error != 0:
+                                        return result.Error.from_e(exc.ResultError(reply.error), "get pdu")
+                                case err:
+                                    return result.Error.from_e(ValueError(F'Got DataBlock-G.result {err}, expect 0 or 1'), "get pdu")
                         case pdu.GetResponse.WITH_LIST:
-                            GXDLMS.handleGetResponseWithList(self.settings, self.reply)
-                            return
-                        case err: raise ValueError(F"Got Invalid Get response {err}, expect {', '.join(map(lambda it: F'{it.name} = {it.value}', pdu.GetResponse))}")
+                            GXDLMS.handleGetResponseWithList(self.settings, reply)
+                            return result.OK
+                        case err:
+                            return result.Error.from_e(ValueError(F"Got Invalid Get response {err}, expect {', '.join(map(lambda it: F'{it.name} = {it.value}', pdu.GetResponse))}"), "get pdu")
                 case XDLMSAPDU.READ_RESPONSE:
-                    if not GXDLMS.handleReadResponse(self.settings, self.reply, index):
-                        return
+                    if not GXDLMS.handleReadResponse(self.settings, reply, index):
+                        return result.OK
                 case XDLMSAPDU.SET_RESPONSE:
-                    response_type: int = self.reply.data.getUInt8()
-                    invoke_id_and_priority = self.reply.data.getUInt8()  # TODO: matching with setting params
+                    response_type: int = reply.data.getUInt8()
+                    invoke_id_and_priority = reply.data.getUInt8()  # TODO: matching with setting params
                     match response_type:
                         case pdu.SetResponse.NORMAL:
-                            self.reply.error = pdu.DataAccessResult(self.reply.data.getUInt8())
-                            if self.reply.error != 0:
-                                raise exc.ResultError(self.reply.error)
+                            reply.error = pdu.DataAccessResult(reply.data.getUInt8())
+                            if reply.error != 0:
+                                return result.Error.from_e(exc.ResultError(reply.error), "get pdu")
                         case pdu.SetResponse.DATABLOCK:
-                            block_number = self.reply.data.getUInt32()
+                            block_number = reply.data.getUInt32()
                         case pdu.SetResponse.LAST_DATABLOCK:
-                            self.reply.error = pdu.DataAccessResult(self.reply.data.getUInt8())
-                            if self.reply.error != 0:
-                                raise exc.ResultError(self.reply.error)
-                            block_number = self.reply.data.getUInt32()
+                            reply.error = pdu.DataAccessResult(reply.data.getUInt8())
+                            if reply.error != 0:
+                                return result.Error.from_e(exc.ResultError(reply.error), "get pdu")
+                            block_number = reply.data.getUInt32()
                         case pdu.SetResponse.LAST_DATABLOCK_WITH_LIST:
-                            raise ValueError("Not released in Client")
+                            raise RuntimeError("Not released in Client")
                         case pdu.SetResponse.WITH_LIST:
-                            cnt = _GXCommon.getObjectCount(self.reply.data)
+                            cnt = _GXCommon.getObjectCount(reply.data)
                             pos = 0
                             while pos != cnt:
-                                self.reply.error = pdu.DataAccessResult(self.reply.data.getUInt8())
-                                if self.reply.error != 0:
-                                    raise exc.ResultError(self.reply.error)
+                                reply.error = pdu.DataAccessResult(reply.data.getUInt8())
+                                if reply.error != 0:
+                                    return result.Error.from_e(exc.ResultError(reply.error), "get pdu")
                                 pos += 1
-                        case err: raise ValueError(F"Got Invalid Set response {err}, expect {', '.join(map(lambda it: F'{it.name} = {it.value}', pdu.SetResponse))}")
+                        case err:
+                            return result.Error.from_e(ValueError(F"Got Invalid Set response {err}, expect {', '.join(map(lambda it: F'{it.name} = {it.value}', pdu.SetResponse))}"), "get pdu")
                 case XDLMSAPDU.WRITE_RESPONSE:
-                    cnt = _GXCommon.getObjectCount(self.reply.data)
+                    cnt = _GXCommon.getObjectCount(reply.data)
                     pos = 0
                     while pos != cnt:
-                        ret = self.reply.data.getUInt8()
+                        ret = reply.data.getUInt8()
                         if ret != 0:
-                            self.reply.error = self.reply.data.getUInt8()
+                            reply.error = reply.data.getUInt8()
                         pos += 1
                 case XDLMSAPDU.ACTION_RESPONSE:
-                    action_response = self.reply.data.getUInt8()
-                    invoke_id_and_priority = self.reply.data.getUInt8()
+                    action_response = reply.data.getUInt8()
+                    invoke_id_and_priority = reply.data.getUInt8()
                     match action_response:
                         case pdu.ActionResponse.NORMAL:
-                            self.reply.error = pdu.ActionResult(self.reply.data.getUInt8())
-                            if self.reply.error != 0:
-                                raise exc.ResultError(self.reply.error)
-                            if self.reply.data.position < self.reply.data.size:
-                                ret = self.reply.data.getUInt8()
+                            reply.error = pdu.ActionResult(reply.data.getUInt8())
+                            if reply.error != 0:
+                                return result.Error(exc.ResultError(reply.error), "get pdu")
+                            if reply.data.position < reply.data.size:
+                                ret = reply.data.getUInt8()
                                 if ret == 0:
-                                    GXDLMS.getDataFromBlock(self.reply.data, 0)
+                                    GXDLMS.getDataFromBlock(reply.data, 0)
                                 elif ret == 1:
-                                    ret = int(self.reply.data.getUInt8())
+                                    ret = int(reply.data.getUInt8())
                                     if ret != 0:
-                                        self.reply.error = self.reply.data.getUInt8()
-                                        if ret == 9 and self.reply.getError() == 16:
-                                            self.reply.data.position = self.reply.data.position - 2
-                                            GXDLMS.getDataFromBlock(self.reply.data, 0)
-                                            self.reply.error = 0
+                                        reply.error = reply.data.getUInt8()
+                                        if ret == 9 and reply.error == 16:
+                                            reply.data.position = reply.data.position - 2
+                                            GXDLMS.getDataFromBlock(reply.data, 0)
+                                            reply.error = 0
                                             ret = 0
                                     else:
-                                        GXDLMS.getDataFromBlock(self.reply.data, 0)
+                                        GXDLMS.getDataFromBlock(reply.data, 0)
                                 else:
-                                    raise Exception("HandleActionResponseNormal failed. " + "Invalid tag.")
+                                    return result.Error.from_e(Exception("HandleActionResponseNormal failed. " + "Invalid tag."), "get pdu")
                         case pdu.ActionResponse.WITH_PBLOCK:
-                            raise ValueError("Not released in Client")
+                            raise RuntimeError("Not released in Client")
                         case pdu.ActionResponse.WITH_LIST:
-                            raise ValueError("Not released in Client")
+                            raise RuntimeError("Not released in Client")
                         case pdu.ActionResponse.NEXT_PBLOCK:
-                            raise ValueError("Not released in Client")
+                            raise RuntimeError("Not released in Client")
                         case err:
-                            raise ValueError(F"got {pdu.ActionResponse}: {err}, expect {', '.join(map(lambda it: F'{it.name} = {it.value}', pdu.ActionResponse))}")
+                            return result.Error.from_e(ValueError(F"got {pdu.ActionResponse}: {err}, expect {', '.join(map(lambda it: F'{it.name} = {it.value}', pdu.ActionResponse))}"), "get pdu")
                 case XDLMSAPDU.ACCESS_RESPONSE:
-                    data = self.reply.data
-                    invokeId = self.reply.data.getUInt32()
-                    len_ = self.reply.data.getUInt8()
+                    data = reply.data
+                    invokeId = reply.data.getUInt32()
+                    len_ = reply.data.getUInt8()
                     tmp = None
                     if len_ != 0:
                         tmp = bytearray(len_)
                         data.get(tmp)
-                        self.reply.time = _GXCommon.changeType(self.settings, tmp, DataType.DATETIME)
+                        reply.time = _GXCommon.changeType(self.settings, tmp, DataType.DATETIME)
                     data.getUInt8()
                 case XDLMSAPDU.GENERAL_BLOCK_TRANSFER:
-                    if not self.settings.isServer and (self.reply.moreData & RequestTypes.FRAME) == 0:
-                        self.handleGbt()
+                    if not self.settings.isServer and (reply.moreData & RequestTypes.FRAME) == 0:
+                        if isinstance(res_gbt := self.handleGbt(reply), result.Error):
+                            return res_gbt
                 case ACSEAPDU.AARQ | ACSEAPDU.AARE:
                     # This is parsed later.
-                    self.reply.data.position = self.reply.data.position - 1
+                    reply.data.position = reply.data.position - 1
                 case ACSEAPDU.RLRE | ACSEAPDU.RLRQ:
                     pass
                 case XDLMSAPDU.CONFIRMED_SERVICE_ERROR:
-                    GXDLMS.handleConfirmedServiceError(self.reply)
+                    GXDLMS.handleConfirmedServiceError(reply)
                 case XDLMSAPDU.EXCEPTION_RESPONSE:
-                    GXDLMS.handleExceptionResponse(self.reply)
+                    GXDLMS.handleExceptionResponse(reply)
                 case XDLMSAPDU.GET_REQUEST | XDLMSAPDU.READ_REQUEST | XDLMSAPDU.WRITE_REQUEST | XDLMSAPDU.SET_REQUEST | XDLMSAPDU.ACTION_REQUEST:
                     pass
                 case XDLMSAPDU.GLO_READ_REQUEST | XDLMSAPDU.GLO_WRITE_REQUEST | XDLMSAPDU.GLO_GET_REQUEST | XDLMSAPDU.GLO_SET_REQUEST | XDLMSAPDU.GLO_ACTION_REQUEST | \
                      XDLMSAPDU.DED_GET_REQUEST | XDLMSAPDU.DED_SET_REQUEST | XDLMSAPDU.DED_ACTION_REQUEST:
                     if self.settings.cipher is None:
-                        raise ValueError("Secure connection is not supported.")
-                    if (self.reply.moreData & RequestTypes.FRAME) == 0:
-                        self.reply.data.position = self.reply.data.position - 1
+                        return result.Error.from_e(ServiceError("Secure connection is not supported."), "get pdu")
+                    if (reply.moreData & RequestTypes.FRAME) == 0:
+                        reply.data.position = reply.data.position - 1
                         p = None
                         if self.settings.cipher.dedicatedKey and (OSI.APPLICATION in self.level):
                             p = AesGcmParameter(self.settings.sourceSystemTitle, self.settings.cipher.dedicatedKey, self.settings.cipher.authenticationKey)
                         else:
                             p = AesGcmParameter(self.settings.sourceSystemTitle, self.settings.cipher.blockCipherKey, self.settings.cipher.authenticationKey)
-                        tmp = GXCiphering.decrypt(self.settings.cipher, p, self.reply.data)
-                        self.reply.data.clear()
-                        self.reply.data.set(tmp)
-                        self.reply.command = XDLMSAPDU(self.reply.data.getUInt8())
-                        if self.reply.command == XDLMSAPDU.DATA_NOTIFICATION or self.reply.command == XDLMSAPDU.INFORMATION_REPORT_REQUEST:
-                            self.reply.command = None
-                            self.reply.data.position = self.reply.data.position - 1
-                            self.getPdu()
+                        tmp = GXCiphering.decrypt(self.settings.cipher, p, reply.data)
+                        reply.data.clear()
+                        reply.data.set(tmp)
+                        reply.command = XDLMSAPDU(reply.data.getUInt8())
+                        if reply.command == XDLMSAPDU.DATA_NOTIFICATION or reply.command == XDLMSAPDU.INFORMATION_REPORT_REQUEST:
+                            reply.command = None
+                            reply.data.position = reply.data.position - 1
+                            if isinstance(res_pdu := self.getPdu(reply), result.Error):
+                                return res_pdu
                     else:
-                        self.reply.data.position = self.reply.data.position - 1
+                        reply.data.position = reply.data.position - 1
                 case XDLMSAPDU.GLO_READ_RESPONSE | XDLMSAPDU.GLO_WRITE_RESPONSE | XDLMSAPDU.GLO_GET_RESPONSE | XDLMSAPDU.GLO_SET_RESPONSE | XDLMSAPDU.GLO_ACTION_RESPONSE | \
                      XDLMSAPDU.GENERAL_GLO_CIPHERING | XDLMSAPDU.GLO_EVENT_NOTIFICATION_REQUEST | XDLMSAPDU.DED_GET_RESPONSE | XDLMSAPDU.DED_SET_RESPONSE | \
                      XDLMSAPDU.DED_ACTION_RESPONSE | XDLMSAPDU.GENERAL_DED_CIPHERING | XDLMSAPDU.DED_EVENT_NOTIFICATION_REQUEST:
                     if self.settings.cipher is None:
-                        raise ValueError("Secure connection is not supported.")
-                    if (self.reply.moreData & RequestTypes.FRAME) == 0:
-                        self.reply.data.position = self.reply.data.position - 1
-                        bb = GXByteBuffer(self.reply.data)
-                        self.reply.data.size = self.reply.data.position = index
+                        return result.Error.from_e(ServiceError("Secure connection is not supported."), "get pdu")
+                    if (reply.moreData & RequestTypes.FRAME) == 0:
+                        reply.data.position = reply.data.position - 1
+                        bb = GXByteBuffer(reply.data)
+                        reply.data.size = reply.data.position = index
                         p = None
                         if self.settings.cipher.dedicatedKey and (OSI.APPLICATION in self.level):
                             p = AesGcmParameter(0, self.settings.sourceSystemTitle, self.settings.cipher.dedicatedKey, self.settings.cipher.authenticationKey)
                         else:
                             p = AesGcmParameter(0, self.settings.sourceSystemTitle, self.settings.cipher.blockCipherKey, self.settings.cipher.authenticationKey)
-                        self.reply.data.set(GXCiphering.decrypt(self.settings.cipher, p, bb))
-                        self.reply.command = None
-                        self.getPdu()
-                        self.reply.cipherIndex = self.reply.data.size
+                        reply.data.set(GXCiphering.decrypt(self.settings.cipher, p, bb))
+                        reply.command = None
+                        if isinstance(res_pdu := self.getPdu(reply), result.Error):
+                            return res_pdu
+                        reply.cipherIndex = reply.data.size
                 case XDLMSAPDU.DATA_NOTIFICATION:
-                    GXDLMS.handleDataNotification(self.settings, self.reply)
-                    data = self.reply.data
+                    GXDLMS.handleDataNotification(self.settings, reply)
+                    data = reply.data
                     start = data.position - 1
                     invokeId = data.getUInt32()
-                    self.reply.time = None
+                    reply.time = None
                     len_ = data.getUInt8()
                     tmp = None
                     if len_ != 0:
@@ -546,103 +554,121 @@ class Client:
                             dt = DataType.DATE
                         info = _GXDataInfo()
                         info.type_ = dt
-                        self.reply.time = _GXCommon.getData(self.settings, GXByteBuffer(tmp), info)
-                    GXDLMS.getDataFromBlock(self.reply.data, start)
-                    GXDLMS.getValueFromData(self.settings, self.reply)
+                        reply.time = _GXCommon.getData(self.settings, GXByteBuffer(tmp), info)
+                    GXDLMS.getDataFromBlock(reply.data, start)
+                    GXDLMS.getValueFromData(self.settings, reply)
                 case XDLMSAPDU.EVENT_NOTIFICATION_REQUEST:
                     pass
                 case XDLMSAPDU.INFORMATION_REPORT_REQUEST:
                     pass
                 case XDLMSAPDU.GENERAL_CIPHERING:
                     if self.settings.cipher is None:
-                        raise ValueError("Secure connection is not supported.")
-                    if (self.reply.moreData & RequestTypes.FRAME) == 0:
-                        self.reply.data.position = self.reply.data.position - 1
+                        return result.Error.from_e(ServiceError("Secure connection is not supported."), "get pdu")
+                    if (reply.moreData & RequestTypes.FRAME) == 0:
+                        reply.data.position = reply.data.position - 1
                         p = AesGcmParameter(0, self.settings.sourceSystemTitle, self.settings.cipher.blockCipherKey, self.settings.cipher.authenticationKey)
-                        tmp = GXCiphering.decrypt(self.settings.cipher, p, self.reply.data)
-                        self.reply.data.clear()
-                        self.reply.data.set(tmp)
-                        self.reply.command = None
+                        tmp = GXCiphering.decrypt(self.settings.cipher, p, reply.data)
+                        reply.data.clear()
+                        reply.data.set(tmp)
+                        reply.command = None
                         if p.security:
-                            self.getPdu()
+                            if isinstance(res_pdu := self.getPdu(reply), result.Error):
+                                return res_pdu
                 case XDLMSAPDU.GATEWAY_REQUEST:
                     pass
                 case XDLMSAPDU.GATEWAY_RESPONSE:
-                    self.reply.data.getUInt8()
-                    len_ = _GXCommon.getObjectCount(self.reply.data)
+                    reply.data.getUInt8()
+                    len_ = _GXCommon.getObjectCount(reply.data)
                     pda = bytearray(len_)
-                    self.reply.data.get(pda)
-                    GXDLMS.getDataFromBlock(self.reply, index)
-                    self.reply.command = None
-                    self.getPdu()
-                case _:                                                                       raise ValueError("Invalid PDU Command.")
-        elif (self.reply.moreData & RequestTypes.FRAME) == 0:
-            if not self.reply.peek and self.reply.moreData == RequestTypes.NONE:
-                if self.reply.command == ACSEAPDU.AARE or self.reply.command == ACSEAPDU.AARQ:
-                    self.reply.data.position = 0
+                    reply.data.get(pda)
+                    GXDLMS.getDataFromBlock(reply, index)
+                    reply.command = None
+                    if isinstance(res_pdu := self.getPdu(reply), result.Error):
+                        return res_pdu
+                case _:
+                    return result.Error.from_e(ValueError("Invalid PDU Command."), "get pdu")
+        elif (reply.moreData & RequestTypes.FRAME) == 0:
+            if not reply.peek and reply.moreData == RequestTypes.NONE:
+                if reply.command == ACSEAPDU.AARE or reply.command == ACSEAPDU.AARQ:
+                    reply.data.position = 0
                 else:
-                    self.reply.data.position = 1
-            if self.reply.command == XDLMSAPDU.GENERAL_BLOCK_TRANSFER:
-                self.reply.data.position = self.reply.cipherIndex + 1
-                self.handleGbt()
-                self.reply.cipherIndex = self.reply.data.size
-                self.reply.command = None
+                    reply.data.position = 1
+            if reply.command == XDLMSAPDU.GENERAL_BLOCK_TRANSFER:
+                reply.data.position = reply.cipherIndex + 1
+                if isinstance(res_gbt := self.handleGbt(reply), result.Error):
+                    return res_gbt
+                reply.cipherIndex = reply.data.size
+                reply.command = None
             elif self.settings.isServer:
-                if self.reply.command in (
+                if reply.command in (
                         XDLMSAPDU.GLO_READ_REQUEST, XDLMSAPDU.GLO_WRITE_REQUEST, XDLMSAPDU.GLO_GET_REQUEST, XDLMSAPDU.GLO_SET_REQUEST, XDLMSAPDU.GLO_ACTION_REQUEST,
                         XDLMSAPDU.GLO_EVENT_NOTIFICATION_REQUEST, XDLMSAPDU.DED_GET_REQUEST, XDLMSAPDU.DED_SET_REQUEST, XDLMSAPDU.DED_ACTION_REQUEST,
                         XDLMSAPDU.DED_EVENT_NOTIFICATION_REQUEST):
-                    self.reply.command = None
-                    self.reply.data.position = self.reply.getCipherIndex()
-                    self.getPdu()
+                    reply.command = None
+                    reply.data.position = reply.getCipherIndex()
+                    if isinstance(res_pdu := self.getPdu(reply), result.Error):
+                        return res_pdu
             else:
-                self.reply.command = None
-                if self.reply.command in (
-                        XDLMSAPDU.GLO_READ_RESPONSE, XDLMSAPDU.GLO_WRITE_RESPONSE, XDLMSAPDU.GLO_GET_RESPONSE, XDLMSAPDU.GLO_SET_RESPONSE, XDLMSAPDU.GLO_ACTION_RESPONSE,
-                        XDLMSAPDU.DED_GET_RESPONSE, XDLMSAPDU.DED_SET_RESPONSE, XDLMSAPDU.DED_ACTION_RESPONSE, XDLMSAPDU.GENERAL_GLO_CIPHERING, XDLMSAPDU.GENERAL_DED_CIPHERING):
-                    self.reply.data.position = self.reply.cipherIndex
-                    self.getPdu()
-                if self.reply.command == XDLMSAPDU.READ_RESPONSE and self.reply.totalCount > 1:
-                    if not GXDLMS.handleReadResponse(self.settings, self.reply, 0):
-                        return
+                reply.command = None
+                if reply.command in (
+                        XDLMSAPDU.GLO_READ_RESPONSE,
+                        XDLMSAPDU.GLO_WRITE_RESPONSE,
+                        XDLMSAPDU.GLO_GET_RESPONSE,
+                        XDLMSAPDU.GLO_SET_RESPONSE,
+                        XDLMSAPDU.GLO_ACTION_RESPONSE,
+                        XDLMSAPDU.DED_GET_RESPONSE,
+                        XDLMSAPDU.DED_SET_RESPONSE,
+                        XDLMSAPDU.DED_ACTION_RESPONSE,
+                        XDLMSAPDU.GENERAL_GLO_CIPHERING,
+                        XDLMSAPDU.GENERAL_DED_CIPHERING
+                ):
+                    reply.data.position = reply.cipherIndex
+                    if isinstance(res_pdu := self.getPdu(reply), result.Error):
+                        return res_pdu
+                if (
+                    reply.command == XDLMSAPDU.READ_RESPONSE
+                    and reply.totalCount > 1
+                ):
+                    if not GXDLMS.handleReadResponse(self.settings, reply, 0):
+                        return result.OK
 
         if (
-            self.reply.command == XDLMSAPDU.READ_RESPONSE
-            and self.reply.commandType == ReadResponse.DATA_BLOCK_RESULT
-            and (self.reply.moreData & RequestTypes.FRAME) != 0
+            reply.command == XDLMSAPDU.READ_RESPONSE
+            and reply.commandType == ReadResponse.DATA_BLOCK_RESULT
+            and (reply.moreData & RequestTypes.FRAME) != 0
         ):
-            return
+            return result.OK
         if (
-            self.reply.data.position != self.reply.data.size
+            reply.data.position != reply.data.size
             and (
-                self.reply.moreData == RequestTypes.NONE
-                or self.reply.peek)
-            and self.reply.command in (
+                reply.moreData == RequestTypes.NONE
+                or reply.peek)
+            and reply.command in (
                 XDLMSAPDU.READ_RESPONSE,
                 XDLMSAPDU.GET_RESPONSE,
                 XDLMSAPDU.ACTION_RESPONSE,
                 XDLMSAPDU.DATA_NOTIFICATION)
         ):
-            pass
-            # GXDLMS.getValueFromData(self.settings, self.reply)
+            return result.OK
+            # GXDLMS.getValueFromData(self.settings, reply)
 
-    def __is_frame(self, notify, read_data: bytearray) -> bool:
+    def __is_frame(self, notify, read_data: bytearray, reply_: GXReplyData) -> bool:
         reply = GXByteBuffer(read_data)
         is_notify: bool = False
         match self.com_profile:
             case c_pf.HDLC():
-                recv_frame = self.get_frame(read_data)
+                recv_frame = self.get_frame(read_data, reply_)
                 if recv_frame is not None:
                     self.log(logL.INFO, F"RX: {recv_frame.content.hex(' ')}")
                     if recv_frame.control == frame.Control.UI_PF:
-                        target = notify  # use instead of self.reply in getPdu(target). see in Gurux to do
+                        target = notify  # use instead of reply_ in getPdu(target). see in Gurux to do
                         is_notify = True
-                    self.reply.frameId = recv_frame.control
+                    reply_.frameId = recv_frame.control
                 else:       # TODO: GURUX redundant
                     # self.write_trace(F"RX {self.id}: {get_os_time()}  {read_data}", TraceLevel.ERROR)
-                    self.reply.frameId = frame.Control(0)
+                    reply_.frameId = frame.Control(0)
             case c_pf.TCPUDPIP():  # getTcpData TODO: check it
-                target = self.reply
+                target = reply_
                 if len(reply) - reply.position < 8:
                     target.complete = False
                     return True
@@ -690,46 +716,44 @@ class Client:
                         break
                     else:
                         reply.position = reply.position - 1
-                if target is not self.reply:
+                if target is not reply_:
                     is_notify = True
             case c_pf.MBUS():  # not realised see how
-                GXDLMS.getMBusData(self.settings, reply, self.reply)
+                GXDLMS.getMBusData(self.settings, reply, reply_)
             case _:                raise ValueError("Invalid Interface type.")
-        if not self.reply.complete:
+        if not reply_.complete:
             return False
 
         # TODO: relocate notify to read_data_type
         if notify and not is_notify:
             #Check command to make sure it's not notify message.
-            if self.reply.command in (XDLMSAPDU.DATA_NOTIFICATION,
+            if reply_.command in (XDLMSAPDU.DATA_NOTIFICATION,
                                       XDLMSAPDU.GLO_EVENT_NOTIFICATION_REQUEST,
                                       XDLMSAPDU.INFORMATION_REPORT_REQUEST,
                                       XDLMSAPDU.EVENT_NOTIFICATION_REQUEST,
                                       XDLMSAPDU.DED_INFORMATION_REPORT_REQUEST,
                                       XDLMSAPDU.DED_EVENT_NOTIFICATION_REQUEST):
                 is_notify = True
-                notify.complete = self.reply.complete
-                notify.command = self.reply.command
-                self.reply.command = None
-                self.reply.time = None
-                notify.self.reply.set(self.reply.data)
-                # notify.value = self.reply.value
-                self.reply.data.trim()
+                notify.complete = reply_.complete
+                notify.command = reply_.command
+                reply_.command = None
+                reply_.time = None
+                notify.reply_.set(reply_.data)
+                # notify.value = reply_.value
+                reply_.data.trim()
         if is_notify:
             return False
         return True
 
-    async def read_data_block(self) -> Any:  # todo: 1.make return pdu, 2.make depend from CommunicationProfile
-        ret = None
+    async def read_data_block(self) -> result.SimpleOrError[bytes]:  # todo: make depend from CommunicationProfile
         self.received_frames.clear()
-        self.reply.clear()
+        reply = GXReplyData()
         while self.send_frames:
-            # TODO: see how remove self.reply here !!!
             send_frame = self.send_frames.popleft()
             notify = GXReplyData()
-            self.reply.error = 0
+            reply.error = 0
             recv_buf: bytearray = bytearray()
-            if not self.reply.isStreaming():
+            if not reply.isStreaming():
                 await self.media.send(send_frame.content)
                 self.log(logL.INFO, F"TX: {send_frame.content.hex(" ")}")
             attempt: int = 1
@@ -738,7 +762,7 @@ class Client:
                     await asyncio.wait_for(                 # todo: don't work exception!!!! Why????
                         fut=self.media.receive(recv_buf),
                         timeout=self.com_profile.parameters.inactivity_time_out)  # todo: only for HDLC
-                    if self.__is_frame(notify, recv_buf):
+                    if self.__is_frame(notify, recv_buf, reply):
                         break
                     elif notify.data.size != 0:
                         if not notify.isMoreData():
@@ -751,37 +775,40 @@ class Client:
                     await self.media.send(send_frame.content)
                     attempt += 1
             else:
-                raise exc.Timeout("Failed to receive reply from the device in given time")
+                return result.Error.from_e(TimeoutError("Failed to receive reply from the device in given time"), "read data block")
             recv_buf.clear()
-            match self.reply.error:
-                case 0:                        """errors is absence"""
-                case 4:                        raise exc.NoObject
-                case _:                        raise GXDLMSException(self.reply.error)
+            match reply.error:
+                case 0:
+                    """errors is absence"""
+                case 4:
+                    return result.Error.from_e(exc.NoObject(), "read data block")
+                case _:
+                    return result.Error.from_e(GXDLMSException(reply.error), "read data block")
             if self.received_frames[-1].control.is_info() or self.received_frames[-1].control == frame.Control.UI_PF:
                 if self.received_frames[-1].is_segmentation:
                     """pass handle frame. wait all information"""
                 else:
                     llc = sub_layer.LLC(frame.Frame.join_info(self.received_frames))
 
-                    self.reply.data.position = len(self.reply.data)
-                    self.reply.data.set(llc.info)
-                    ret = self.getPdu()
-
+                    reply.data.position = len(reply.data)
+                    reply.data.set(llc.info)
+                    if isinstance(res_pdu := self.getPdu(reply), result.Error):
+                        return res_pdu
                     # TODO: LLC to PDU
             else:
                 received_frame = self.received_frames.popleft()
                 if send_frame.control == frame.Control.SNRM_P:
                     self.com_profile.negotiation.set_from_UA(received_frame.info)
                     self.log(logL.INFO, F"negotiation setup: {self.com_profile.negotiation}")
-            if self.reply.isMoreData():
-                if self.reply.isStreaming():
+            if reply.isMoreData():
+                if reply.isStreaming():
                     data = None
                 else:
                     # Generates an acknowledgment message, with which the server is informed to send next packets. Frame type. Acknowledgment message as byte array
-                    if self.reply.moreData == RequestTypes.NONE:
-                        raise ValueError("Invalid receiverReady RequestTypes parameter.")
+                    if reply.moreData == RequestTypes.NONE:
+                        return result.Error.from_e(ValueError("Invalid receiverReady RequestTypes parameter."), msg="read data block")
                     #  Get next frame.
-                    if (self.reply.moreData & RequestTypes.FRAME) != 0:
+                    if (reply.moreData & RequestTypes.FRAME) != 0:
                         id_ = self.settings.getReceiverReady()
                         # return GXDLMS.getHdlcFrame(settings, id_, None)
                         self.add_frames_to_queue(frame.Control(id_))
@@ -796,13 +823,13 @@ class Client:
                                 cmd = XDLMSAPDU.READ_RESPONSE
                             else:
                                 cmd = XDLMSAPDU.READ_REQUEST
-                        if self.reply.moreData == RequestTypes.GBT:
+                        if reply.moreData == RequestTypes.GBT:
                             p = GXDLMSLNParameters(self.settings, 0, XDLMSAPDU.GENERAL_BLOCK_TRANSFER, 0, None, None, 0xff)
-                            p.WindowSize = self.reply.windowSize
-                            p.blockNumberAck = self.reply.blockNumberAck
-                            p.blockIndex = self.reply.blockNumber
+                            p.WindowSize = reply.windowSize
+                            p.blockNumberAck = reply.blockNumberAck
+                            p.blockIndex = reply.blockNumber
                             p.Streaming = False
-                            reply = self.getLnMessages(p)  # TODO: test it
+                            messages = self.getLnMessages(p)  # TODO: test it
                         else:
                             #  Get next block.
                             bb = GXByteBuffer(4)
@@ -813,12 +840,12 @@ class Client:
                             self.settings.increaseBlockIndex()
                             if self.settings.getUseLogicalNameReferencing():
                                 p = GXDLMSLNParameters(self.settings, 0, cmd, pdu.GetResponse.WITH_DATABLOCK, bb, None, 0xff)
-                                reply = self.getLnMessages(p)
+                                messages = self.getLnMessages(p)
                             else:
                                 p = GXDLMSSNParameters(self.settings, cmd, 1, VariableAccessSpecification.BLOCK_NUMBER_ACCESS, bb, None)
-                                reply = self.getSnMessages(p)
-                        data = reply
-        return ret
+                                messages = self.getSnMessages(p)
+                        data = messages
+        return result.Simple(reply.data.get_data())
 
     def getSnMessages(self, p: GXDLMSSNParameters):
         reply = GXByteBuffer()
@@ -864,8 +891,8 @@ class Client:
                     if p.settings.is_multiple_block():
                         reply.size = 0
                         if (
-                                not ciphering
-                                and isinstance(self.com_profile, c_pf.HDLC)
+                            not ciphering
+                            and isinstance(self.com_profile, c_pf.HDLC)
                         ):
                             if p.settings.isServer:
                                 reply.set(_GXCommon.LLC_REPLY_BYTES)
@@ -970,36 +997,31 @@ class Client:
     def set_params(self, field: str, value: str):
         self.__dict__[field] = eval(value)
 
-    async def close(self) -> None:
+    async def close(self) -> result.StrictOk | result.Error:
         """close , media is open"""
+        res = result.StrictOk()
         self.log(logL.DEB, "close")
         if self.level > OSI.DATA_LINK:
-            try:
-                # Release is call only for secured connections. All meters are not supporting Release and it's causing problems.
-                if (
+            # Release is call only for secured connections. All meters are not supporting Release and it's causing problems.
+            if (
                     isinstance(self.com_profile, c_pf.TCPUDPIP)
                     or (
-                        isinstance(self.com_profile, c_pf.HDLC)
-                        and self.settings.cipher.security != Security.NONE
-                    )
-                ):
-                    self.releaseRequest()
-                    await self.read_data_block()
-            except Exception:
-                self.log(logL.WARN, "don't support release ReleaseRequest")
-                pass
-                #  All meters don't support release.
-            finally:
-                self.level = OSI.DATA_LINK
+                    isinstance(self.com_profile, c_pf.HDLC)
+                    and self.settings.cipher.security != Security.NONE
+            )
+            ):
+                self.releaseRequest()
+                if isinstance(res_rdb := await self.read_data_block(), result.Error):
+                    res.append_err(res_rdb.err)
+                    self.log(logL.WARN, "don't support release ReleaseRequest")
+            self.level = OSI.DATA_LINK
             # hdlc close
-            try:
-                res = await self.disconnect_request()
-                # todo: handle res
-            except Exception as e:
-                self.log(logL.ERR, F'Disconnect request ERROR: {e.args[0]}')
+            if isinstance(res_diconnect_req := await self.disconnect_request(), result.Error):
+                res.append_err(res_diconnect_req.err)
         self.level -= OSI.DATA_LINK
+        return res
 
-    async def disconnect_request(self):
+    async def disconnect_request(self) -> result.Ok | result.Error:
         """ Sent to server DISC """
         if isinstance(self.com_profile, c_pf.HDLC):
             self.add_frames_to_queue(frame.Control.DISC_P)
@@ -1026,10 +1048,10 @@ class Client:
             return ret
 
     # TODO: remove in future
-    def parseApplicationAssociationResponse(self):
+    def parseApplicationAssociationResponse(self, data: bytes):
         """ Parse server's challenge if HLS authentication is used. Received reply from the server. todo: refactoring here """
         ic = 0
-        value = cdt.OctetString(self.reply.data.get_data())
+        value = cdt.OctetString(data)
         match self.m_id:
             case mechanism_id.HIGH_GMAC:
                 secret = self.settings.sourceSystemTitle
@@ -1135,8 +1157,9 @@ class Client:
         else:
             return self.method2(0xFA00, 12, 8, challenge, cdt.OctetString.TAG)  # TODO: rewrite old client.method
 
-    def parseAARE(self, buff: GXByteBuffer) -> AcseServiceUser:
+    def parseAARE(self, pdu: bytes) -> AcseServiceUser:
         #  Get AARE tag and length
+        buff = GXByteBuffer(pdu)
         tag = buff.getUInt8()
         if self.settings.isServer:
             if tag != (BerType.APPLICATION | BerType.CONSTRUCTED | AARQapdu.PROTOCOL_VERSION):
@@ -1452,11 +1475,11 @@ class Client:
         #     raise exc.AssociationResultError(resultComponent, resultDiagnosticValue)
         return resultDiagnosticValue
 
-    def parseAareResponse(self, reply) -> AcseServiceUser:
+    def parseAareResponse(self, pdu: bytes) -> AcseServiceUser:
         """ TODO: need refactoring. Parses the AARE response.  Parse method will update the following data: DLMSVersion, MaxReceivePDUSize, UseLogicalNameReferencing, LNSettings or SNSettings,
         LNSettings or SNSettings will be updated, depending on the referencing, Logical name or Short name.
         Received data. GXDLMSClient#aarqRequest GXDLMSClient#useLogicalNameReferencing GXDLMSClient#negotiatedConformance GXDLMSClient#proposedConformance """
-        if (ret := self.parseAARE(reply)) != AcseServiceUser.AUTHENTICATION_REQUIRED:
+        if (ret := self.parseAARE(pdu)) != AcseServiceUser.AUTHENTICATION_REQUIRED:
             self.level |= OSI.APPLICATION
         if self.settings.dlmsVersion != 6:
             raise ValueError("Invalid DLMS version number.")
@@ -1581,7 +1604,7 @@ class Client:
 
     def getLnMessages(self, p: GXDLMSLNParameters):
         reply = GXByteBuffer()
-        messages = list()
+        messages = []
         frame_ = 0
         if (
             p.command == XDLMSAPDU.DATA_NOTIFICATION
@@ -2037,6 +2060,7 @@ class Client:
         else:
             return 'недоступен'
 
+    @deprecated("<use ReadObjAttr>")
     async def read_attribute(self, obj: ic.COSEMInterfaceClasses | str,
                              attr_index: int):
         # TODO: redundant, use read_attr?
@@ -2046,44 +2070,25 @@ class Client:
             value=attr_index,
             with_selection=bool(self.negotiated_conformance.selective_access)))
         start_read_time: float = time.perf_counter()
-        await self.read_data_block()
+        data = (await self.read_data_block()).unwrap()
         self.last_transfer_time = datetime.timedelta(seconds=time.perf_counter()-start_read_time)
-        obj.set_attr(attr_index, self.reply.data.get_data())
-
-    async def read_attr(self, attr_desc: ut.CosemAttributeDescriptor) -> bytes:
-        """instead <read_attribute> in future. Read and return encoding"""
-        self.get_get_request_normal(attr_desc)
-        await self.read_data_block()
-        return self.reply.data.get_data()
-
-    def recv_attr_value(self, attr_desc: ut.CosemAttributeDescriptor) -> cdt.CommonDataTypes:
-        """receive attribute value from server"""
-        obj = self.objects.get_object(attr_desc)
-        index = int(attr_desc.attribute_id)
-        obj.set_attr(index=index,
-                     value=self.read_attr(attr_desc))
-        return obj.get_attr(index)
-
-    async def write_attr2(self, attr_desc: ut.CosemAttributeDescriptor, value: cdt.CommonDataTypes):
-        data = self.get_set_request_normal2(attr_desc, value)
-        await self.read_data_block()
+        obj.set_attr(attr_index, data)
 
     @deprecated("use execute_method2")
-    async def execute_method(self, meth_desc: ut.CosemMethodDescriptor):
+    async def execute_method(self, meth_desc: ut.CosemMethodDescriptor) -> result.Ok | result.Error:
         data = self.get_action_request_normal_old(meth_desc)
-        await self.read_data_block()
+        return await self.read_data_block()
 
-    async def execute_method2(self, obj: ic.COSEMInterfaceClasses, i: int, mip=None):
+    async def execute_method2(self, obj: ic.COSEMInterfaceClasses, i: int, mip=None) -> result.Ok | result.Error:
         data = self.get_action_request_normal(
             meth_desc=obj.get_meth_descriptor(i),
             method=obj.get_meth_element(i).DATA_TYPE() if mip is None else mip)
-        await self.read_data_block()
+        return await self.read_data_block()
 
     async def is_equal_attribute(self, obj: ic.COSEMInterfaceClasses, attr_index: int | str, with_time: bool | datetime.datetime = False) -> bool:
         self.get_get_request_normal(obj.get_attr_descriptor(attr_index))
-        await self.read_data_block()
-        if obj.get_attr(attr_index).encoding == self.reply.data.get_data():
+        data = (await self.read_data_block()).unwrap()
+        if obj.get_attr(attr_index).encoding == data:
             return True
         else:
-            # self.set_error(Application.VALUE_ERROR, F'{obj} attr-{attr_index}: got {self.reply.data.get_data()} must {obj[attr_index]}')
             return False