DLMS-SPODES-client 0.19.5__py3-none-any.whl → 0.19.7__py3-none-any.whl

DLMS_SPODES_client/client.py

@@ -970,7 +970,7 @@ class Client:
     def set_params(self, field: str, value: str):
         self.__dict__[field] = eval(value)
 
-    async def close(self):
+    async def close(self) -> None:
         """close , media is open"""
         self.log(logL.DEB, "close")
         if self.level > OSI.DATA_LINK:

DLMS_SPODES_client/task.py

@@ -5,7 +5,7 @@ import re
 from typing_extensions import deprecated
 import hashlib
 from dataclasses import dataclass, field
-from typing import Callable, Any, Optional, Protocol, cast, override, Self, Final, Iterable
+from typing import Callable, Any, Optional, Protocol, cast, override, Self, Final, Iterable, TypeVarTuple
 from itertools import count
 import datetime
 import time
@@ -35,7 +35,8 @@ from DLMS_SPODES.firmwares import get_firmware
 from DLMS_SPODES.cosem_interface_classes.image_transfer import image_transfer_status as i_t_status
 from DLMSAdapter.main import AdapterException, Adapter, gag
 from DLMSCommunicationProfile.osi import OSI
-from .client import Client, logL, Security, Data, mechanism_id, AcseServiceUser, State
+from .logger import LogLevel as logL
+from .client import Client, Security, Data, mechanism_id, AcseServiceUser, State
 
 
 firm_id_pat = re.compile(b".*(?P<fid>PWRM_M2M_[^_]{1,10}_[^_]{1,10}).+")
@@ -56,7 +57,7 @@ class Base[T: result.Result](Protocol):
     def copy(self) -> Self: ...
 
     @property
-    def current(self) -> 'Base[T]':
+    def current(self) -> 'Base[T] | Self':
         return self
 
     async def run(self, c: Client) -> T | result.Error:
@@ -516,7 +517,7 @@ class List[T: result.Result, U: Base[result.Result]](Subtasks[U], _List[T]):
         )
 
     @property
-    def current(self) -> 'Base[T]':
+    def current(self) -> 'Base[T] | Self':
         return self.__current
 
     def append(self, task: Base[T]):
@@ -546,16 +547,16 @@ class Sequence[*Ts](Subtasks[Base[result.Result]], _Sequence[*Ts]):
     """for exchange task sequence"""
     msg: str
     err_ignore: bool
-    __current: Base[result.Result]
-    tasks: Base[*Ts]
+    __current: "Base[result.Result] | Sequence[*Ts]"
+    tasks: tuple[Base[result.Result], ...]
 
-    def __init__(self, *tasks: *Ts, msg: str = "", err_ignore: bool = False):
+    def __init__(self, *tasks: Base[result.Result], msg: str = "", err_ignore: bool = False):
         self.tasks = tasks
         self.__current = self
         self.msg = self.__class__.__name__ if msg == "" else msg
         self.err_ignore = err_ignore
 
-    def copy(self) -> Self:
+    def copy(self) -> "Sequence[*Ts]":
         if all((isinstance(t, SimpleCopy) for t in self.tasks)):
             return self
         return Sequence(
@@ -565,24 +566,23 @@ class Sequence[*Ts](Subtasks[Base[result.Result]], _Sequence[*Ts]):
         )
 
     @property
-    def current(self) -> Base[result.Result]:
+    def current(self) -> Base[result.Result] | Self:
         return self.__current
 
     async def exchange(self, c: Client) -> result.Sequence[*Ts] | result.Error:
-        res_: list[*Ts] = [result.NULL] * len(self.tasks)
-        acc = result.ErrorAccumulator()
-        for i, t in enumerate(self.tasks):
+        res = result.Sequence()
+        for t in self.tasks:
             self.__current = t
             try:
-                res_[i] = acc.propagate_err(await t.exchange(c))
+                if (
+                    isinstance(res_one := await t.exchange(c), result.Error)
+                    and not self.err_ignore
+                ):
+                    return res_one
+                res = res.add(res_one)
             except exc.ResultError as e:  # todo: make without except
-                acc.propagate_err(result.Error.from_e(e, msg=t.msg))
-            if (
-                not self.err_ignore
-                and not acc.is_ok()
-            ):
-                return acc.as_error()
-        return result.Sequence(*res_, err=acc.err)
+                res.add(result.Error.from_e(e).with_msg(t.msg))
+        return cast("result.Sequence[*Ts]", res)
 
 
 class SetLocalTime(SimpleCopy, OK):
@@ -1162,9 +1162,10 @@ class ReadAttributes(SimpleCopy, _List[cdt.CommonDataType]):
 
 
 @dataclass
+@deprecated("use <Write2>")
 class Write(SimpleCopy, OK):
     """write with ParameterData struct"""
-    par_data: ParData
+    pardata: ParData
     msg: str = "write attribute"
 
     async def exchange(self, c: Client) -> result.Ok | result.Error:
@@ -1188,6 +1189,34 @@ class Write(SimpleCopy, OK):
         return result.OK
 
 
+@dataclass
+class Write2(SimpleCopy, OK):
+    """write with ParameterData struct"""
+    par: Parameter
+    data: cdt.CommonDataType
+    msg: str = "write Data"
+
+    async def exchange(self, c: Client) -> result.Ok | result.Error:
+        if isinstance(res_obj := c.objects.par2obj(self.par), result.Error):
+            return res_obj
+        if self.par.n_elements == 0:
+            enc = self.data.encoding
+        elif isinstance(res_read := await ReadObjAttr(res_obj.value, self.par.i).exchange(c), result.Error):
+            return res_read
+        else:
+            data = a_data
+            for el in self.par.elements():
+                data = data[el]
+            data.set(self.data)
+            enc = data.encoding
+        data = c.get_set_request_normal(
+            obj=res_obj.value,
+            attr_index=self.par.i,
+            value=enc)
+        ret = await c.read_data_block()
+        return result.OK
+
+
 @dataclass
 class WriteParValue(SimpleCopy, OK):
     """write with ParameterValues struct"""
@@ -1694,6 +1723,7 @@ class AccessValidate(Base[result.Ok | result.Simple[list[Parameter]]]):
 
 
 @dataclass
+@deprecated("use <WriteList>")
 class WriteParDatas(SimpleCopy, _List[result.Ok]):
     """write by ParData list"""
     par_datas: list[ParData]
@@ -1710,37 +1740,68 @@ class WriteParDatas(SimpleCopy, _List[result.Ok]):
         return res
 
 
+class WriteList(SimpleCopy, _List[result.Ok]):
+    """write by list"""
+    par_datas: tuple[Parameter, cdt.CommonDataType]
+    err_ignore: bool
+
+    def __init__(self, *par_datas: tuple[Parameter, cdt.CommonDataType], err_ignore: bool = False, msg = ""):
+        self.par_datas = par_datas
+        self.err_ignore = err_ignore
+        self.msg = msg
+
+    async def exchange(self, c: Client) -> result.List[result.Ok] | result.Error:
+        res = result.List[result.Ok]()
+        for par, data in self.par_datas:
+            if (
+                isinstance(res_one := await Write2(par, data).exchange(c), result.Error)
+                and not self.err_ignore
+            ):
+                return res_one
+            res.append(res_one)
+        return res
+
+
 @dataclass
 class WriteParTranscript(SimpleCopy, OK):
     """write by ParValues[Transcript]"""
-    par_value: ParValues[cdt.Transcript]
+    par: Parameter
+    value: cdt.Transcript
     msg: str = ""
 
     async def exchange(self, c: Client) -> result.Ok | result.Error:
-        par, value = self.par_value
-        if isinstance((res := await Par2Data(par).exchange(c)), result.Error):
+        if isinstance((res := await Par2Data(self.par).exchange(c)), result.Error):
             return res
         data = copy(res.value)
         if isinstance(data, cdt.Digital):
-            s_u = c.objects.par2su(par)
+            s_u = c.objects.par2su(self.par)
             if isinstance(s_u, cdt.ScalUnitType):
-                value = int(float(value) * 10 ** -int(s_u.scaler))
-        data.set(value)
+                value = int(float(self.value) * 10 ** -int(s_u.scaler))
+        data.set(self.value)
         return await WriteAttribute(
-            ln=self.par_value.par.obis,
-            index=self.par_value.par.i,
+            ln=self.par.obis,
+            index=self.par.i,
             value=data.encoding
         ).exchange(c)
 
 
-@dataclass
-class WriteParTranscripts(SimpleCopy, Base):
+class WriteParTranscripts(SimpleCopy, _List[result.Ok]):
     """write by ParValues[Transcript] list"""
-    par_values: Final[list[ParValues[cdt.Transcript]]]
-    msg: str = ""
+    par_values: tuple[Parameter, cdt.Transcript]
+    err_ignore: bool
 
-    async def exchange(self, c: Client) -> result.List:
-        res = result.List()
-        for par_value in self.par_values:
-            WriteParTranscript(par_value)
+    def __init__(self, *par_values: tuple[Parameter, cdt.Transcript], err_ignore: bool = False, msg=""):
+        self.par_values = par_values
+        self.err_ignore = err_ignore
+        self.msg = msg
+
+    async def exchange(self, c: Client) -> result.List[T] | result.Error:
+        res = result.List[result.Ok]()
+        for par, value in self.par_values:
+            if (
+                isinstance(res_one := await WriteParTranscript(par, value).exchange(c), result.Error)
+                and not self.err_ignore
+            ):
+                return res_one
+            res.append(res_one)
         return res

{dlms_spodes_client-0.19.5.dist-info → dlms_spodes_client-0.19.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DLMS_SPODES_client
-Version: 0.19.5
+Version: 0.19.7
 Summary: dlms-spodes
 Author-email: Serj Kotilevski <youserj@outlook.com>
 Project-URL: Source, https://github.com/youserj/SPODESclient_prj

{dlms_spodes_client-0.19.5.dist-info → dlms_spodes_client-0.19.7.dist-info}/RECORD

@@ -1,12 +1,12 @@
 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=O6Z6lHcPzQ8YCxXYhw1Jo_m9Lz2EkoQ48InvDpBlEp8,110442
+DLMS_SPODES_client/client.py,sha256=SHAJzsfoJBACcFnqFRPEdaRosgHEjRrKRvXkB0Nnsyo,110450
 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=OuVX4Q8BIKbUE3RCyf7qru9TfNDIOjBrL3ooXK-uDxI,73301
+DLMS_SPODES_client/task.py,sha256=9A13pYO0n335nv7sDPu83Rg0cQP_-StCLkw2QZZ_m9Y,75566
 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
@@ -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.5.dist-info/METADATA,sha256=H3mlYrQaOvG2AL9fkK_irjJy0X0ifgONBSYePi4XUF4,985
-dlms_spodes_client-0.19.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dlms_spodes_client-0.19.5.dist-info/entry_points.txt,sha256=Z6UTeQjjCf2k1Y3Bjs0s7yr-UYSWb-TvJMuG2K2MApw,70
-dlms_spodes_client-0.19.5.dist-info/top_level.txt,sha256=rh_3Uig5bc6J_lKni01btol7dX_IgIJulNtGjGehmBE,19
-dlms_spodes_client-0.19.5.dist-info/RECORD,,
+dlms_spodes_client-0.19.7.dist-info/METADATA,sha256=6ulnXqlGP0-tPH_pafbEQfO7Q9FTNEdQE_F8q-j0hSQ,985
+dlms_spodes_client-0.19.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dlms_spodes_client-0.19.7.dist-info/entry_points.txt,sha256=Z6UTeQjjCf2k1Y3Bjs0s7yr-UYSWb-TvJMuG2K2MApw,70
+dlms_spodes_client-0.19.7.dist-info/top_level.txt,sha256=rh_3Uig5bc6J_lKni01btol7dX_IgIJulNtGjGehmBE,19
+dlms_spodes_client-0.19.7.dist-info/RECORD,,