DLMS-SPODES-client 0.19.13__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:
@@ -328,9 +331,11 @@ 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):
@@ -371,7 +376,8 @@ 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
 
 
@@ -497,7 +503,7 @@ class List[T: result.Result, U: Base[result.Result]](Subtasks[U], _List[T]):
     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
@@ -528,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
 
 
@@ -570,15 +570,12 @@ 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):
-                    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 = res.add(result.Error.from_e(e).with_msg(self.msg))
+            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)
         return cast("result.Sequence[*Ts]", res)
 
 
@@ -613,6 +610,16 @@ class GetFirmwareVersion(SimpleCopy, CDT):
         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]):
     msg: str = "try find COSEM server version, return: instance(B group), CDT"
@@ -620,22 +627,24 @@ class FindFirmwareVersion(SimpleCopy, Simple[collection.ParameterValue]):
     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)
@@ -645,22 +654,24 @@ class FindFirmwareId(SimpleCopy, Simple[collection.ParameterValue]):
     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(frozen=True)
@@ -678,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
@@ -749,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>")
 
@@ -762,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))
@@ -776,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:
@@ -990,6 +1002,7 @@ get_adapter(gag)  # Dummy Adapter
 
 
 @dataclass
+@deprecated("use <ReadObjAttr>")
 class ReadAttribute(SimpleCopy, CDT):
     ln: collection.LNContaining
     index: int
@@ -1013,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)
@@ -1182,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
 
 
@@ -1210,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
 
 
@@ -1250,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
 
 
@@ -1276,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
 
 
@@ -1328,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)
@@ -1341,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,
@@ -1561,56 +1581,36 @@ 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 = "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
@@ -1674,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 = "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

{dlms_spodes_client-0.19.13.dist-info → dlms_spodes_client-0.19.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DLMS_SPODES_client
-Version: 0.19.13
+Version: 0.19.14
 Summary: dlms-spodes
 Author-email: Serj Kotilevski <youserj@outlook.com>
 Project-URL: Source, https://github.com/youserj/SPODESclient_prj
@@ -15,7 +15,7 @@ Requires-Dist: pycryptodomex>=3.22.0
 Requires-Dist: semver>=3.0
 Requires-Dist: StructResult<0.10,>=0.9.2
 Requires-Dist: DLMS-SPODES-communications<1.5,>=1.4.9
-Requires-Dist: DLMS_SPODES<0.88,>=0.87.7
+Requires-Dist: DLMS_SPODES<0.88,>=0.87.8
 Requires-Dist: DLMSadapter<0.8,>=0.7.5
 Requires-Dist: DLMSCommunicationProfile<0.2,>=0.1.11
 Requires-Dist: numpy>=2.3.2

{dlms_spodes_client-0.19.13.dist-info → dlms_spodes_client-0.19.14.dist-info}/RECORD

@@ -1,17 +1,17 @@
 DLMS_SPODES_client/FCS16.py,sha256=RhoN4fX7eesKWfWCkRT_uWNfiQHqFd3T6lRwxfamUqw,2697
 DLMS_SPODES_client/__init__.py,sha256=6wphXvqkodng7h4nKNmkfldbaxf--IDVGfT0yNbas-o,449
-DLMS_SPODES_client/client.py,sha256=WuWg9OW3uRMQ4EtcWPEqUuG9QQLjNyL-JR2gZSTUifo,112222
+DLMS_SPODES_client/client.py,sha256=T_8nI6_tCWK6Us74gjIM_2I8EtETs4dQX4ygFmnV70A,112333
 DLMS_SPODES_client/logger.py,sha256=zAbihLloMU99w8Sw3djQ0cwItzyGq0Fz8DI9_suazv4,1913
 DLMS_SPODES_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 DLMS_SPODES_client/services.py,sha256=xM_-h322V1bGBcw9cJh7XOSUMTL3_E-GX89-z3YwIYw,3909
 DLMS_SPODES_client/session.py,sha256=1sa4wJny2xwDqL3DXpfYTS7mZcabVdC5fW1H60VB5QA,12681
 DLMS_SPODES_client/settings.py,sha256=6mitGe9UYeEgL61sf933MJ-S5N-ReoxvXqiI3agBGYE,1623
-DLMS_SPODES_client/task.py,sha256=xgiEk7Fu3pp24rgVcRQ_R2asK9rZwA0KhtZXfvZYi6Q,76509
+DLMS_SPODES_client/task.py,sha256=W-tlB3iqkz1ui_QmvXq_ON90Xhiln1Y1a0PgZI3Mtb8,76260
 DLMS_SPODES_client/gurux_common/enums/TraceLevel.py,sha256=Ne0Rn3c9ACqQjmde_ksbiQxIUv6nXsPQRnhkGwIv3QI,521
 DLMS_SPODES_client/gurux_common/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 DLMS_SPODES_client/gurux_dlms/AesGcmParameter.py,sha256=HJt0uvxtkqKEkvfiqXTMNsiayN15AgPJa9_iMSSFZsQ,1429
 DLMS_SPODES_client/gurux_dlms/CountType.py,sha256=VtpybVSaPpCq6Me3WkYk3SLmIPgi6Yp32IUjuJ-7fAo,264
-DLMS_SPODES_client/gurux_dlms/GXByteBuffer.py,sha256=qoq5h8HlBltIwkvWyK42lRL6eV_KDFXjlZT0OMhNgTo,17658
+DLMS_SPODES_client/gurux_dlms/GXByteBuffer.py,sha256=MiX-fegn-Ptfu8jHzocckDFhf4oZSNCpNOMONgZ1d44,17708
 DLMS_SPODES_client/gurux_dlms/GXCiphering.py,sha256=Py0PFm4PVUrxIZEN4UmBAok0UZ0nH1JpGGLes0aOhjk,5909
 DLMS_SPODES_client/gurux_dlms/GXDLMS.py,sha256=Up5hQpoS2MPbycDW1vjQprbKWGOC5xBYuvnvpAdLBrk,17458
 DLMS_SPODES_client/gurux_dlms/GXDLMSChippering.py,sha256=HxOtiyOUrdFreEcUHNCU8oq9dBgtvX8g65q932cDb1w,10122
@@ -21,7 +21,7 @@ DLMS_SPODES_client/gurux_dlms/GXDLMSException.py,sha256=SME3os97MbZ-b65z2HQvU40b
 DLMS_SPODES_client/gurux_dlms/GXDLMSLNParameters.py,sha256=JxFiv8Xh8VC2VcogoprKsun6iTZX_kyz3Qho8MdO-GM,1347
 DLMS_SPODES_client/gurux_dlms/GXDLMSSNParameters.py,sha256=dKDVbtTUsG3Y_39TUVZXVvNcsyxpPVWvdNsXAFgxzGY,699
 DLMS_SPODES_client/gurux_dlms/GXDLMSSettings.py,sha256=fCXt2j1smev-r_iW-hP_PyCJzHEZzXF87_1LARse8GE,8146
-DLMS_SPODES_client/gurux_dlms/GXReplyData.py,sha256=Aq8G5aAK__NzNzAh6YIZ-KZPeu0HtqTKi3aTJ7UfOMQ,4476
+DLMS_SPODES_client/gurux_dlms/GXReplyData.py,sha256=XDddMjyzlCmyQJ5XOMjz1lstAbk5Xu0DKYx1_DyFkCI,3057
 DLMS_SPODES_client/gurux_dlms/HdlcControlFrame.py,sha256=uB_lZfutg0xj8of7Rjhg4iYEFb08Z4BR3KLCMj0ih4g,193
 DLMS_SPODES_client/gurux_dlms/MBusCommand.py,sha256=VlSbupvSReAb-n9QeeQcksjdQ_hFRtpwiPCOZo4k2u0,143
 DLMS_SPODES_client/gurux_dlms/MBusEncryptionMode.py,sha256=InIXEUNhq_IENiXfxHO-PRnDAF7PgZ_yNNNBAssXQgo,623
@@ -54,8 +54,8 @@ DLMS_SPODES_client/gurux_dlms/enums/Task.py,sha256=chuOL6-IMxBvABUZtoFcaYaQQB4GZ
 DLMS_SPODES_client/gurux_dlms/enums/VdeStateError.py,sha256=qT87LMbIYEs3TYPIp3N-dR2Tcg9KhKyiELwhVl5U-tw,233
 DLMS_SPODES_client/gurux_dlms/enums/__init__.py,sha256=F_sgGwNmmdpbKvP1klJQUNiLXxU2BtZ-LgEI9e6xP8g,1314
 DLMS_SPODES_client/gurux_dlms/internal/_GXCommon.py,sha256=7D9EYcfiZxwbk8sfpHv7s2nYqrbmGf-Tbwv2T-gqmgk,53226
-dlms_spodes_client-0.19.13.dist-info/METADATA,sha256=T6U2znlwbvDl53LDxlksEmmOXJKGett3mwG5QeR08UI,986
-dlms_spodes_client-0.19.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dlms_spodes_client-0.19.13.dist-info/entry_points.txt,sha256=Z6UTeQjjCf2k1Y3Bjs0s7yr-UYSWb-TvJMuG2K2MApw,70
-dlms_spodes_client-0.19.13.dist-info/top_level.txt,sha256=rh_3Uig5bc6J_lKni01btol7dX_IgIJulNtGjGehmBE,19
-dlms_spodes_client-0.19.13.dist-info/RECORD,,
+dlms_spodes_client-0.19.14.dist-info/METADATA,sha256=2JnJR8pivvNowQChuQcYsa9nyTjw5ZFBGWUpeoRyZCk,986
+dlms_spodes_client-0.19.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dlms_spodes_client-0.19.14.dist-info/entry_points.txt,sha256=Z6UTeQjjCf2k1Y3Bjs0s7yr-UYSWb-TvJMuG2K2MApw,70
+dlms_spodes_client-0.19.14.dist-info/top_level.txt,sha256=rh_3Uig5bc6J_lKni01btol7dX_IgIJulNtGjGehmBE,19
+dlms_spodes_client-0.19.14.dist-info/RECORD,,