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

DLMS_SPODES_client/task.py

@@ -86,19 +86,21 @@ class Base[T: result.Result](Protocol):
         ):
             if isinstance(res := await init_type.data_link(c), result.Error):
                 return res.with_msg("PH_connect")
-            await c.close()  # todo: change to DiscRequest, or make not closed or reconnect !!!
+            if isinstance(res_close := await c.close(), result.Error):  # todo: change to DiscRequest, or make not closed or reconnect !!!
+                return res_close
         return result.OK
 
     @staticmethod
-    async def physical_t(c: Client) -> None:
-        await c.close()
+    async def physical_t(c: Client) -> result.Ok | result.Error:
+        return await c.close()
 
     async def physical(self, c: Client) -> T | result.Error:
         if OSI.PHYSICAL not in c.level:
             if isinstance((res := await self.PH_connect(c)), result.Error):
                 return res
         ret = await self.data_link(c)
-        await self.physical_t(c)
+        if isinstance(res_terminate := await self.physical_t(c), result.Error):
+            return res_terminate
         return ret
 
     async def DL_connect(self, c: Client) -> None:
@@ -113,8 +115,6 @@ class Base[T: result.Result](Protocol):
         c.SA = frame.Address(upper_address=int(c.SAP))
         c.log(logL.INFO, F"{c.SA=} {c.DA=}")
         # initialize connection
-        c.reply.clear()
-        # replace this
         if c.settings.cipher.security != Security.NONE:
             c.log(logL.DEB, F"Security: {c.settings.cipher.security}/n"
                             F"System title: {c.settings.cipher.systemTitle.hex()}"
@@ -124,9 +124,9 @@ class Base[T: result.Result](Protocol):
                 c.log(logL.DEB, F"Dedicated key: {c.settings.cipher.dedicatedKey.hex()}")
         # SNRM
         c.get_SNRM_request()
-        await c.read_data_block()
+        if isinstance(res_pdu := await c.read_data_block(), result.Error):
+            return res_pdu
         c.level |= OSI.DATA_LINK
-        c.reply.clear()
 
     async def data_link(self, c: Client) -> T | result.Error:
         if OSI.DATA_LINK not in c.level:
@@ -134,7 +134,7 @@ class Base[T: result.Result](Protocol):
         # todo: make tile
         return await self.application(c)
 
-    async def AA(self, c: Client) -> None:
+    async def AA(self, c: Client) -> result.Ok | result.Error:
         """Application Associate"""
         if c.invocationCounter and c.settings.cipher is not None and c.settings.cipher.security != Security.NONE:
             # create IC object. TODO: remove it after close connection, maybe???
@@ -149,17 +149,19 @@ class Base[T: result.Result](Protocol):
             challenge = c.settings.ctoSChallenge
             try:
                 c.aarqRequest(c.m_id)
-                await c.read_data_block()
-                ret = c.parseAareResponse(c.reply.data)
+                if isinstance(res_pdu := await c.read_data_block(), result.Error):
+                    return res_pdu
+                ret = c.parseAareResponse(res_pdu.value)
                 c.level |= OSI.APPLICATION  # todo: it's must be result of <ret> look down
-                c.reply.clear()
-                await c.read_attribute(IC, 2)
-                c.settings.cipher.invocationCounter = 1 + int(IC.value)
+                if isinstance(res_ic := await ReadObjAttr(IC, 2).exchange(c), result.Error):
+                    return res_ic
+                c.settings.cipher.invocationCounter = 1 + int(res_ic.value)
                 c.log(logL.DEB, "Invocation counter: " + str(c.settings.cipher.invocationCounter))
                 # disconnect
                 if c.media and c.media.is_open():
                     c.log(logL.DEB, "DisconnectRequest")
-                    await c.disconnect_request()
+                    if isinstance(res_disc_req := await c.disconnect_request(), result.Error):
+                        return res_disc_req
             finally:
                 c.SAP = tmp_client_SAP
                 c.settings.useCustomChallenge = challenge is not None
@@ -206,40 +208,41 @@ class Base[T: result.Result](Protocol):
             #     self.client.ctoSChallenge = challenge
 
         c.aarqRequest(c.m_id)
-        await c.read_data_block()
+        if isinstance(res_pdu := await c.read_data_block(), result.Error):
+            return res_pdu
         # await c.read_attr(ut.CosemAttributeDescriptor((collection.ClassID.ASSOCIATION_LN, ut.CosemObjectInstanceId("0.0.40.0.0.255"), ut.CosemObjectAttributeId(6)))) # for test only
-        match c.parseAareResponse(c.reply.data):
+        match c.parseAareResponse(res_pdu.value):
             case AcseServiceUser.NULL:
-                c.log(logL.INFO, 'Authentication success')
+                c.log(logL.INFO, "Authentication success")
                 c.level |= OSI.APPLICATION
             case AcseServiceUser.AUTHENTICATION_REQUIRED:
-                c.reply.clear()
                 c.getApplicationAssociationRequest()
-                await c.read_data_block()
-                c.parseApplicationAssociationResponse()
+                if isinstance(res_pdu := await c.read_data_block(), result.Error):
+                    return res_pdu
+                c.parseApplicationAssociationResponse(res_pdu.value)
             case _ as diagnostic:
-                raise exc.AssociationResultError(diagnostic)
+                return result.Error.from_e(exc.AssociationResultError(diagnostic))
         if c._objects is not None:
-            c.get_get_request_normal(c._objects.LDN.get_attr_descriptor(2))
-            await c.read_data_block()
             if c.is_universal():
                 await change_ldn.exchange(c)
             else:
                 await match_ldn.exchange(c)
+        return result.OK
 
     async def application(self, c: Client) -> T | result.Error:
         if OSI.APPLICATION not in c.level:
-            await self.AA(c)
+            if isinstance(res := await self.AA(c), result.Error):
+                return res
         # no tile
         return await self.exchange(c)
 
     async def exchange(self, c: Client) -> T | result.Error:
         """application level exchange"""
 
-    async def connect(self, c: Client) -> None:
+    async def connect(self, c: Client) -> result.Ok | result.Error:
         await self.PH_connect(c)
         await self.DL_connect(c)
-        await self.AA(c)
+        return await self.AA(c)
 
 
 class SimpleCopy:
@@ -291,11 +294,11 @@ class StrictOK(Base[result.StrictOk], Protocol):
     async def exchange(self, c: Client) -> result.StrictOk | result.Error: ...
 
 
-@dataclass
+@dataclass(frozen=True)
 class ClientBlocking(SimpleCopy, OK):
     """complete by time or abort"""
-    delay: Final[float] = field(default=99999999.0)
-    msg: str = ""
+    delay: float = field(default=99999999.0)
+    msg: str = "client blocking"
 
     async def run(self, c: Client) -> result.Ok | result.Error:
         try:
@@ -312,8 +315,9 @@ class ClientBlocking(SimpleCopy, OK):
 
 
 # todo: make with <data_link>
+@dataclass
 class TestDataLink(SimpleCopy, OK):
-    msg: str = ""
+    msg: str = "test DLink"
 
     async def physical(self, c: Client) -> result.Ok | result.Error:
         if OSI.PHYSICAL not in c.level:
@@ -327,27 +331,29 @@ class TestDataLink(SimpleCopy, OK):
             )
             c.SA = frame.Address(upper_address=int(c.SAP))
             c.get_SNRM_request()
-            await c.read_data_block()
+            if isinstance(res_pdu := await c.read_data_block(), result.Error):
+                return res_pdu
             c.level |= OSI.DATA_LINK
-            await c.close()  # todo: change to DiscRequest
+            if isinstance(res_close := await c.close(), result.Error):  # todo: change to DiscRequest
+                return res_close
         return result.Ok
 
     async def exchange(self, c: Client):
         return result.OK
 
 
-@dataclass
+@dataclass(frozen=True)
 class Dummy(SimpleCopy, OK):
-    msg: str = ""
+    msg: str = "dummy"
 
     async def exchange(self, c: Client) -> result.Ok | result.Error:
         """"""
         return result.OK
 
 
-@dataclass
+@dataclass(frozen=True)
 class HardwareDisconnect(SimpleCopy, OK):
-    msg: str = ""
+    msg: str = "hardware disconnect"
 
     @override
     async def exchange(self, c: Client) -> result.Ok | result.Error:
@@ -358,9 +364,9 @@ class HardwareDisconnect(SimpleCopy, OK):
         return result.OK
 
 
-@dataclass
+@dataclass(frozen=True)
 class HardwareReconnect(SimpleCopy, OK):
-    delay: Final[float] = 0.0
+    delay: float = 0.0
     """delay between disconnect and restore Application"""
     msg: str = "reconnect media without response"
 
@@ -370,17 +376,18 @@ class HardwareReconnect(SimpleCopy, OK):
         if self.delay != 0.0:
             c.log(logL.INFO, F"delay({self.delay})")
             await asyncio.sleep(self.delay)
-        await self.connect(c)  # restore Application
+        if isinstance(res_connect := await self.connect(c), result.Error):  # restore Application
+            return res_connect
         return result.OK
 
 
-@dataclass
+@dataclass(frozen=True)
 class Loop(OK):
     task: Base[result.Result]
     func: Callable[[Any], bool]
-    delay: Final[int] = 0.0
-    msg: str = ""
-    attempt_amount: Final[int] = 0
+    delay: int = 0.0
+    msg: str = "loop"
+    attempt_amount: int = 0
     """0 is never end loop"""
 
     def copy(self) -> Self:
@@ -411,7 +418,7 @@ class ConditionalTask[T](Base):
     comp_value: T
     predicate: Callable[[T, T], bool]
     main_task: Base[result.Result]
-    msg: str
+    msg: str = "conditional task"
 
     async def exchange(self, c: Client) -> result.Result:
         res = await self.precondition_task.exchange(c)
@@ -434,7 +441,7 @@ class Scheduler[T: result.Result](Base[T]):
     repetition_delay_min: Final[int] = 1
     repetition_delay_exponent: Final[int] = 100
     repetition_delay_max: Final[int] = 100
-    msg: str = ""
+    msg: str = "sheduler"
 
     def copy(self) -> "Scheduler[T]":
         return Scheduler(
@@ -492,11 +499,11 @@ class Subtasks[U: Base[result.Result]](Protocol):
 class List[T: result.Result, U: Base[result.Result]](Subtasks[U], _List[T]):
     """for exchange task sequence"""
     __is_exchange: bool
-    msg: str
     err_ignore: bool
+    msg: str
     __current: Base[T]
 
-    def __init__(self, *tasks: Base[T], msg: str = "", err_ignore: bool = True):
+    def __init__(self, *tasks: Base[T], msg: str = "", err_ignore: bool = False):
         self.tasks = list(tasks)
         self.__current = self
         self.__is_exchange = False
@@ -527,15 +534,9 @@ class List[T: result.Result, U: Base[result.Result]](Subtasks[U], _List[T]):
         self.__is_exchange = True
         for t in self.tasks:
             self.__current = t
-            try:
-                res.append(await t.exchange(c))
-            except exc.ResultError as e:  # todo: make without except
-                res.append(result.Error.from_e(e, msg=t.msg))
-            if (
-                not self.err_ignore
-                and not res.is_ok()
-            ):
-                break
+            res.append(await t.exchange(c))
+            if not self.err_ignore:
+                return result.Error(res.err)
         return res
 
 
@@ -546,7 +547,7 @@ class Sequence[*Ts](Subtasks[Base[result.Result]], _Sequence[*Ts]):
     __current: "Base[result.Result] | Sequence[*Ts]"
     tasks: tuple[Base[result.Result], ...]
 
-    def __init__(self, *tasks: Base[result.Result], msg: str = "", err_ignore: bool = False):
+    def __init__(self, *tasks: Base[result.Result], msg: str = "sequence", err_ignore: bool = False):
         self.tasks = tasks
         self.__current = self
         self.msg = self.__class__.__name__ if msg == "" else msg
@@ -569,21 +570,19 @@ class Sequence[*Ts](Subtasks[Base[result.Result]], _Sequence[*Ts]):
         res = result.Sequence()
         for t in self.tasks:
             self.__current = t
-            try:
-                if (
-                    isinstance(res_one := await t.exchange(c), result.Error)
-                    and not self.err_ignore
-                ):
+            if isinstance(res_one := await t.exchange(c), result.Error):
+                if self.err_ignore:
+                    res_one = res_one.with_msg(self.msg)
+                else:
                     return res_one
-                res = res.add(res_one)
-            except exc.ResultError as e:  # todo: make without except
-                res.add(result.Error.from_e(e).with_msg(t.msg))
+            res = res.add(res_one)
         return cast("result.Sequence[*Ts]", res)
 
 
+@dataclass(frozen=True)
 class SetLocalTime(SimpleCopy, OK):
     """without decide time transfer"""
-    msg: str
+    msg: str = "set local time"
 
     async def exchange(self, c: Client) -> result.Ok | result.Error:
         clock_obj: Clock = c.objects.get_object("0.0.1.0.0.255")
@@ -603,68 +602,81 @@ class SetLocalTime(SimpleCopy, OK):
         return result.OK
 
 
+@dataclass(frozen=True)
 class GetFirmwareVersion(SimpleCopy, CDT):
-    """get firmware version by Client.id"""
-    msg: str
+    msg: str = "get firmware version"
 
     async def exchange(self, c: Client) -> result.SimpleOrError[cdt.CommonDataType]:
         return await Par2Data(Parameter(c.objects.id.f_ver.par[:6]).get_attr(c.objects.id.f_ver.par[6])).exchange(c)
 
 
+@dataclass(frozen=True)
+class ReadByDescriptor(SimpleCopy, Simple[bytes]):
+    desc: ut.CosemMethodDescriptor
+    msg: str = "get encoding by Cosem-Attribute-Descriptor"
+
+    async def exchange(self, c: Client) -> result.SimpleOrError[bytes]:
+        c.get_get_request_normal(self.desc)
+        return await c.read_data_block()
+
+
+@dataclass(frozen=True)
 class FindFirmwareVersion(SimpleCopy, Simple[collection.ParameterValue]):
-    """try find COSEM server version, return: instance(B group), CDT"""
-    msg: str
+    msg: str = "try find COSEM server version, return: instance(B group), CDT"
 
     async def exchange(self, c: Client) -> result.SimpleOrError[collection.ParameterValue]:
         err = result.ErrorAccumulator()
         for desc in (ut.CosemAttributeDescriptor((1, "0.0.0.2.1.255", 2)), ut.CosemAttributeDescriptor((1, "0.0.96.1.2.255", 2))):
-            try:
+            if isinstance(res_read := await ReadByDescriptor(desc).exchange(c), result.Error):
+                err.append_err(res_read.err)
+                in_e, out_e = res_read.err.split(exc.ResultError)
+                if (
+                    out_e is None
+                    and in_e.exceptions[0].result == pdu.DataAccessResult(4)
+                ):
+                    continue
+                else:
+                    return res_read
+            else:
                 res = result.Simple(collection.ParameterValue(
                     par=desc.instance_id.contents + desc.attribute_id.contents,
-                    value=await c.read_attr(desc)
+                    value=res_read.value
                 ))
                 res.propagate_err(err)
                 return res
-            except exc.ResultError as e:
-                err.append_err(e)
-                if e.result == pdu.DataAccessResult.OBJECT_UNDEFINED:
-                    """try search in old object and set to new"""
-                else:
-                    break
-        if isinstance((res := err.result), result.Error):
-            return res
-        raise RuntimeError(f"empty {err}")
+        return err.as_error()
 
 
+@dataclass(frozen=True)
 class FindFirmwareId(SimpleCopy, Simple[collection.ParameterValue]):
-    """try find COSEM server identifier, return: FirmwareID"""
     msg: str = "find firmaware Identifier"
 
     async def exchange(self, c: Client) -> result.SimpleOrError[collection.ParameterValue]:
         err = result.ErrorAccumulator()
         for desc in (ut.CosemAttributeDescriptor((1, "0.0.0.2.0.255", 2)), ut.CosemAttributeDescriptor((1, "0.0.96.1.1.255", 2))):
-            try:
+            if isinstance(res_read := await ReadByDescriptor(desc).exchange(c), result.Error):
+                err.append_err(res_read.err)
+                in_e, out_e = res_read.err.split(exc.ResultError)
+                if (
+                    out_e is None
+                    and in_e.exceptions[0].result == pdu.DataAccessResult(4)
+                ):
+                    continue
+                else:
+                    return res_read
+            else:
                 res = result.Simple(collection.ParameterValue(
                     par=desc.instance_id.contents + desc.attribute_id.contents,
-                    value=await c.read_attr(desc)
+                    value=res_read.value
                 ))
                 res.propagate_err(err)
                 return res
-            except exc.ResultError as e:
-                err.append_err(e)
-                if e.result==pdu.DataAccessResult.OBJECT_UNDEFINED:
-                    """try search in old object and set to new"""
-                else:
-                    break
-        if isinstance((res := err.result), result.Error):
-            return res
-        raise RuntimeError(f"empty {err}")
+        return err.as_error()
 
 
-@dataclass
+@dataclass(frozen=True)
 class KeepAlive(SimpleCopy, OK):
-    """use read LDN.ln"""
-    msg: str = "keep alive"
+    msg: str = "keep alive(read LND.ln)"
 
     async def exchange(self, c: Client) -> result.Ok | result.Error:
         if isinstance(res := await Par2Data(dlms_par.LDN.value).exchange(c), result.Error):
@@ -677,8 +689,9 @@ class GetLDN(SimpleCopy, CDT[octet_string.LDN]):
     msg: str = "get LDN"
 
     async def exchange(self, c: Client) -> result.SimpleOrError[octet_string.LDN]:
-        data = await c.read_attr(collection.AttrDesc.LDN_VALUE)
-        return result.Simple(octet_string.LDN(data))
+        if isinstance(res := await ReadByDescriptor(collection.AttrDesc.LDN_VALUE).exchange(c), result.Error):
+            return res
+        return result.Simple(octet_string.LDN(res.value))
 
 
 # todo: possible implementation ConditionalTask
@@ -697,7 +710,7 @@ class GetLDN(SimpleCopy, CDT[octet_string.LDN]):
 @dataclass
 class MatchLDN(OK):
     universal: bool = field(default=False)
-    msg: str = ""
+    msg: str = "matching LDN"
 
     async def exchange(self, c: Client) -> result.Ok | result.Error:
         if isinstance((res := await GetLDN().exchange(c)), result.Error):
@@ -748,11 +761,7 @@ class CreateType(SimpleCopy, Simple[collection.Collection]):
     col: collection.Collection = field(init=False)
 
     def __post_init__(self):
-        self.col = collection.Collection(id_=collection.ID(
-            man=self.col_id.man,
-            f_id=self.col_id.f_id,
-            f_ver=self.col_id.f_ver
-        ))
+        self.col = collection.Collection(id_=self.col_id)
         """common collection"""
         self.wait_list = Lock(name="wait <object list>")
 
@@ -761,7 +770,9 @@ class CreateType(SimpleCopy, Simple[collection.Collection]):
         await self.wait_list.acquire(c)
         try:
             if self.obj_list is None:
-                self.obj_list = cdt.Array(await c.read_attr(collection.AttrDesc.OBJECT_LIST), type_=structs.ObjectListElement)
+                if isinstance(res_obj_list := await ReadByDescriptor(collection.AttrDesc.OBJECT_LIST).exchange(c), result.Error):
+                    return res_obj_list
+                self.obj_list = cdt.Array(res_obj_list.value, type_=structs.ObjectListElement)
             if len(self.col) == 0:
                 for country_olel in filter(lambda it: ln_pattern.COUNTRY_SPECIFIC == it.logical_name, self.obj_list):
                     self.col.set_country(collection.CountrySpecificIdentifiers(country_olel.logical_name.d))
@@ -775,9 +786,11 @@ class CreateType(SimpleCopy, Simple[collection.Collection]):
                         country_desc is not None
                         and next(filter(lambda it: country_desc.instance_id.contents == it.logical_name.contents, self.obj_list), False)
                     ):
+                        if isinstance(res_country_ver := await ReadByDescriptor(country_desc).exchange(c), result.Error):
+                            return res_country_ver
                         self.col.set_country_ver(collection.ParameterValue(
                             par=country_desc.instance_id.contents + country_desc.attribute_id.contents,
-                            value=await c.read_attr(country_desc)
+                            value=res_country_ver.value
                         ))
                         c.log(logL.INFO, F"set country version: {self.col.country_ver}")
                     else:
@@ -945,7 +958,7 @@ class MapTypeCreator:
 @dataclass
 class InitType(SimpleCopy, Simple[collection.Collection]):
     adapter: Adapter
-    msg: str = ""
+    msg: str = "initiate type"
 
     async def exchange(self, c: Client) -> result.SimpleOrError[collection.Collection]:
         if isinstance((res := await Sequence(
@@ -989,10 +1002,11 @@ get_adapter(gag)  # Dummy Adapter
 
 
 @dataclass
+@deprecated("use <ReadObjAttr>")
 class ReadAttribute(SimpleCopy, CDT):
     ln: collection.LNContaining
     index: int
-    msg: str = ""
+    msg: str = "read LN attribute"
 
     async def exchange(self, c: Client) -> result.Simple[cdt.CommonDataType]:
         obj = c.objects.get_object(self.ln)
@@ -1003,7 +1017,7 @@ class ReadAttribute(SimpleCopy, CDT):
 class ReadObjAttr(SimpleCopy, CDT):
     obj: collection.InterfaceClass
     index: int
-    msg: str = ""
+    msg: str = "read object attribute"
 
     async def exchange(self, c: Client) -> result.SimpleOrError[cdt.CommonDataType]:
         # TODO: check is_readable?
@@ -1012,10 +1026,11 @@ class ReadObjAttr(SimpleCopy, CDT):
                 value=self.index,
                 with_selection=bool(c.negotiated_conformance.selective_access)))
         start_read_time: float = time.perf_counter()
-        await c.read_data_block()
+        if isinstance(res_pdu := await c.read_data_block(), result.Error):
+            return res_pdu
         c.last_transfer_time = datetime.timedelta(seconds=time.perf_counter()-start_read_time)
         try:
-            self.obj.set_attr(self.index, c.reply.data.get_data())
+            self.obj.set_attr(self.index, res_pdu.value)
             return result.Simple(self.obj.get_attr(self.index))
         except ValueError as e:
             return result.Error.from_e(e)
@@ -1025,7 +1040,7 @@ class ReadObjAttr(SimpleCopy, CDT):
             return result.Error.from_e(e)
 
 
-@dataclass
+@dataclass(frozen=True)
 class Par2Data[T: cdt.CommonDataType](SimpleCopy, CDT[T]):
     """get CommonDataType by Parameter"""
     par: Parameter
@@ -1056,13 +1071,13 @@ def is_empty(value: cdt.CommonDataType | None) -> bool:
     return True if value is None else False
 
 
-@dataclass
+@dataclass(frozen=True)
 class ReadAttributeIf(SimpleCopy, Base):
     """read if func with arg as value is True"""
     ln: collection.LNContaining
     index: int
     func: AttrValueComp
-    msg: str
+    msg: str = "read attribute with condition"
 
     async def exchange(self, c: Client) -> result.Simple[cdt.CommonDataType]:
         # TODO: check is_readable
@@ -1075,7 +1090,7 @@ class ReadAttributeIf(SimpleCopy, Base):
             return result.OK
 
 
-@dataclass
+@dataclass(frozen=True)
 class ReadEmptyAttribute(SimpleCopy, Base):
     ln: collection.LNContaining
     index: int
@@ -1090,7 +1105,7 @@ class ReadEmptyAttribute(SimpleCopy, Base):
         ).exchange(c)
 
 
-@dataclass
+@dataclass(frozen=True)
 class ReadWritableAttributes(SimpleCopy, Base):
     ln: collection.LNContaining
     indexes: tuple[int, ...]
@@ -1116,7 +1131,7 @@ class ReadWritableAttributes(SimpleCopy, Base):
 
 
 # copy past from ReadWritableAttributes
-@dataclass
+@dataclass(frozen=True)
 class ActualizeAttributes(SimpleCopy, OK):
     ln: collection.LNContaining
     indexes: tuple[int, ...]
@@ -1142,7 +1157,7 @@ class ActualizeAttributes(SimpleCopy, OK):
         return result.OK
 
 
-@dataclass
+@dataclass(frozen=True)
 class ReadAttributes(SimpleCopy, _List[cdt.CommonDataType]):
     ln: collection.LNContaining
     indexes: tuple[int, ...]
@@ -1181,7 +1196,8 @@ class Write(SimpleCopy, OK):
             obj=res_obj.value,
             attr_index=self.par_data.par.i,
             value=enc)
-        ret = await c.read_data_block()
+        if isinstance(res_pdu := await c.read_data_block(), result.Error):
+            return res_pdu
         return result.OK
 
 
@@ -1209,7 +1225,8 @@ class Write2(SimpleCopy, OK):
             obj=res_obj.value,
             attr_index=self.par.i,
             value=enc)
-        ret = await c.read_data_block()
+        if isinstance(res_pdu := await c.read_data_block(), result.Error):
+            return res_pdu
         return result.OK
 
 
@@ -1249,7 +1266,8 @@ class WriteParValue(SimpleCopy, OK):
             obj=obj,
             attr_index=self.par_value.par.i,
             value=set_data.encoding)
-        ret = await c.read_data_block()
+        if isinstance(res_pdu := await c.read_data_block(), result.Error):
+            return res_pdu
         return result.OK
 
 
@@ -1275,7 +1293,8 @@ class WriteAttribute(SimpleCopy, OK):
             obj=obj,
             attr_index=self.index,
             value=enc)
-        ret = await c.read_data_block()
+        if isinstance(res_pdu := await c.read_data_block(), result.Error):
+            return res_pdu
         return result.OK  # todo: return Data-Access-Result
 
 
@@ -1327,7 +1346,8 @@ class Execute2(SimpleCopy, OK):
                 meth_desc=res.value.get_meth_descriptor(self.par.i),
                 method=self.data
             )
-            await c.read_data_block()
+            if isinstance(res_pdu := await c.read_data_block(), result.Error):
+                return res_pdu
             return result.OK
         except Exception as e:
             return result.Error.from_e(e)
@@ -1340,8 +1360,9 @@ class WriteTime(SimpleCopy, Base):
         try:
             obj = c._objects.clock
             c.get_get_request_normal(obj.get_attr_descriptor(3))
-            await c.read_data_block()
-            tz = obj.get_attr_element(3).DATA_TYPE(c.reply.data.get_data())
+            if isinstance(res_pdu := await c.read_data_block(), result.Error):
+                return res_pdu
+            tz = obj.get_attr_element(3).DATA_TYPE(res_pdu.value)
             res = await WriteAttribute(
                 ln=obj.logical_name,
                 index=2,
@@ -1361,7 +1382,7 @@ class ImageTransfer(SimpleCopy, StrictOK):
     n_t_b: int = field(init=False, default=0)
     """not transferred block"""
     n_blocks: int = field(init=False)
-    msg: str = ""
+    msg: str = "image transfer"
 
     def __post_init__(self) -> None:
         self.ITI = ImageTransferInitiate((
@@ -1560,62 +1581,42 @@ class ActivateImage(SimpleCopy, OK):
         return result.OK
 
 
-class TestAll(Base):
+# todo: don't work with new API, remake
+class TestAll(OK):
     """read all attributes with check access"""  # todo: add Write with access
-    msg: str = ""
+    msg: str = "test all"
 
-    async def exchange(self, c: Client):
+    async def exchange(self, c: Client) -> result.Ok | result.Error:
         # todo: refactoring with <append_err>
-        res = result.Simple()
-        if await init_type.exchange(c):
-            ass: collection.AssociationLN = c._objects.sap2association(c.SAP)
-            for obj in tuple(c._objects):
-                indexes: list[int] = [i for i, _ in obj.get_index_with_attributes()]
-                attempt = count(1)
-                while True:
-                    c.log(logL.INFO, F"start read {obj} attr: {', '.join(map(str, indexes))}. attempt={next(attempt)}")
-                    len_indexes: int = len(indexes)
-                    for i in tuple(indexes):
-                        is_readable = ass.is_readable(
-                            ln=obj.logical_name,
-                            index=i)
-                        try:
-                            await ReadAttribute(
-                                ln=obj.logical_name,
-                                index=i
-                            ).exchange(c)
-                            if not is_readable:
-                                c.log(logL.ERR, F"{obj} with attr={i} must be unreadable")
-                            indexes.remove(i)
-                            c.log(logL.INFO, F"Get {obj}:{obj.get_attr_element(i)}")
-                            if res.value is None:
-                                c.log(logL.WARN, F"ValueError. For {obj} attr:{i} {res}")
-                        except exc.ResultError as e:
-                            if e.result == pdu.DataAccessResult.READ_WRITE_DENIED and not is_readable:
-                                c.log(logL.INFO, F"success ReadAccess TEST: {e}")
-                                indexes.remove(i)
-                            else:
-                                c.log(logL.ERR, F"result_error {e}")
-                        except exc.ITEApplication as e:
-                            c.log(logL.ERR, F"ITEApplication. For {obj} attr:{i} {e}")
-                        except Exception as e:
-                            c.log(logL.ERR, F"Unknown. For {obj} attr:{i} {e}")
-                    if len(indexes) == 0:
-                        c.log(logL.INFO, "all read success")
-                        break
-                    elif len(indexes) == len_indexes:
-                        c.log(logL.ERR, F"can't read attr={', '.join(map(str, indexes))}")
-                        break
+        res = result.ErrorAccumulator()
+        if isinstance(res_objects := c.objects.sap2objects(c.SAP), result.Error):
+            return res_objects
+        ass: collection.AssociationLN = c.objects.sap2association(c.SAP)
+        for obj in res_objects.value:
+            indexes: list[int] = [i for i, _ in obj.get_index_with_attributes()]
+            c.log(logL.INFO, F"start read {obj} attr: {', '.join(map(str, indexes))}")
+            for i in indexes:
+                is_readable = ass.is_readable(
+                    ln=obj.logical_name,
+                    index=i)
+                if isinstance(res_read := await ReadObjAttr(obj, i).exchange(c), result.Error):
+                    if (
+                        res_read.has(pdu.DataAccessResult.READ_WRITE_DENIED, exc.ResultError)
+                        and not is_readable
+                    ):
+                        c.log(logL.INFO, F"success ReadAccess TEST")
                     else:
-                        c.log(logL.WARN, F"has a errors in attr={', '.join(map(str, indexes))}. Need more attempt")
-                # todo: check write problem - if send_frame clear then counter is wrong, need fix in client it
-            return res
+                        res.append_err(res_read.err)
+                elif not is_readable:
+                    res.append_e(PermissionError(f"{obj} with attr={i} must be unreadable"))
+                    indexes.remove(i)
+        return res.result
 
 
 @dataclass
 class ApplyTemplate(Base):
     template: collection.Template
-    msg: str = ""
+    msg: str = "apply template"
 
     async def exchange(self, c: Client) -> result.Result:
         # todo: search col
@@ -1645,7 +1646,7 @@ class ApplyTemplate(Base):
 @dataclass
 class ReadTemplate(OK):
     template: collection.Template
-    msg: str = ""
+    msg: str = "read template"
 
     async def exchange(self, c: Client) -> result.Ok | result.Error:
         # todo: copypast from <ApplyTemplate>
@@ -1673,50 +1674,39 @@ class ReadTemplate(OK):
 
 
 @dataclass
-class AccessValidate(Base[result.Ok | result.Simple[list[Parameter]]]):
+class AccessValidate(OK):
     """check all access rights for current SAP"""
     with_correct: bool = False
-    msg: str = ""
+    msg: str = "all access validate"
 
     # todo: make with result.Error
-    async def exchange(self, c: Client) -> result.Ok | result.Simple[list[Parameter]] | result.Error:
+    async def exchange(self, c: Client) -> result.Ok | result.Error:
+        res = result.ErrorAccumulator()
         obj_l: ObjectListType
         el: ObjectListElement
         a_a_i: association_ln.abstract.AttributeAccessItem
-        if c._objects is None:
-            return result.Error.from_e(exc.DLMSException("not find Collection"))
-        elif (obj_l := c._objects.sap2association(c.SAP).object_list) is None:
+        if (obj_l := c.objects.sap2association(c.SAP).object_list) is None:
             return result.Error.from_e(exc.EmptyObj(F"empty object_list for {c._objects.sap2association(c.SAP)}"))
-        res = result.Simple(value=[])
         for el in obj_l:
             for a_a_i in el.access_rights.attribute_access:
                 if a_a_i.access_mode.is_readable():
                     i = int(a_a_i.attribute_id)
-                    try:
-                        res_ = await ReadAttribute(
-                            ln=el.logical_name,
-                            index=int(a_a_i.attribute_id)
-                        ).exchange(c)
-                        if a_a_i.access_mode.is_writable():
-                            await WriteAttribute(
-                                ln=el.logical_name,
-                                index=i,
-                                value=res_.value.encoding
-                            ).exchange(c)
-                    except exc.ResultError as e:
-                        res.append_e(e)
-                        res.value.append(Parameter(el.logical_name.contents).set_i(i))
+                    if isinstance(res_read :=await ReadByDescriptor(ut.CosemAttributeDescriptor((
+                            int(el.class_id),
+                            el.logical_name.contents,
+                            i
+                    ))).exchange(c), result.Error):
+                        res.append_err(res_read.err)
                         if self.with_correct:
                             a_a_i.access_mode.set(1)  # todo: make better in future
-                    except exc.Timeout as e:
-                        c.log(logL.ERR, F"for {el.logical_name}: {i} - {e}")
-                        await HardwareReconnect().exchange(c)
-                    except Exception as e:
-                        res.append_e(e)
-                        res.value.append(Parameter(el.logical_name.contents).set_i(i))
-        if not res.is_ok():
-            return res
-        return result.OK
+                    elif a_a_i.access_mode.is_writable():
+                        if isinstance(res_write :=await WriteAttribute(
+                            ln=el.logical_name,
+                            index=i,
+                            value=res_read.value
+                        ).exchange(c), result.Error):
+                            res.append_err(res_write.err)
+        return res.result
 
 
 @dataclass
@@ -1742,7 +1732,7 @@ class WriteList(SimpleCopy, _List[result.Ok]):
     par_datas: tuple[tuple[Parameter, cdt.CommonDataType], ...]
     err_ignore: bool
 
-    def __init__(self, *par_datas: tuple[Parameter, cdt.CommonDataType], err_ignore: bool = False, msg: str = "") -> None:
+    def __init__(self, *par_datas: tuple[Parameter, cdt.CommonDataType], err_ignore: bool = False, msg: str = "write list") -> None:
         self.par_datas = par_datas
         self.err_ignore = err_ignore
         self.msg = msg
@@ -1769,7 +1759,7 @@ class WriteTranscript(SimpleCopy, OK):
     async def exchange(self, c: Client) -> result.Ok | result.Error:
         if isinstance((res := await Par2Data[cdt.CommonDataType](self.par).exchange(c)), result.Error):
             return res
-        if isinstance(data, cdt.Digital):
+        if isinstance(res.value, cdt.Digital):
             s_u = c.objects.par2su(self.par)
             if isinstance(s_u, cdt.ScalUnitType):
                 if not isinstance(self.value, str):
@@ -1790,7 +1780,7 @@ class WriteTranscripts(SimpleCopy, _List[result.Ok]):
     par_values: tuple[tuple[Parameter, cdt.Transcript], ...]
     err_ignore: bool
 
-    def __init__(self, *par_values: tuple[Parameter, cdt.Transcript], err_ignore: bool = False, msg: str =""):
+    def __init__(self, *par_values: tuple[Parameter, cdt.Transcript], err_ignore: bool = False, msg: str ="write transcripts"):
         self.par_values = par_values
         self.err_ignore = err_ignore
         self.msg = msg