DLMS-SPODES 0.87.1__tar.gz → 0.87.3__tar.gz

{dlms_spodes-0.87.1 → dlms_spodes-0.87.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DLMS_SPODES
-Version: 0.87.1
+Version: 0.87.3
 Summary: dlms-spodes
 Author-email: Serj Kotilevski <youserj@outlook.com>
 Project-URL: Source, https://github.com/youserj/DlmsSPODES-project

{dlms_spodes-0.87.1 → dlms_spodes-0.87.3}/pyproject.toml

@@ -14,7 +14,7 @@ exclude = ["test","KPZ"]
 
 [project]
 name = "DLMS_SPODES"
-version = "0.87.1"
+version = "0.87.3"
 authors = [
     {name="Serj Kotilevski", email="youserj@outlook.com"}
 ]

{dlms_spodes-0.87.1 → dlms_spodes-0.87.3}/src/DLMS_SPODES/cosem_interface_classes/parameter.py

@@ -1,5 +1,5 @@
 from typing_extensions import deprecated
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import numpy as np
 from struct import Struct, pack, unpack_from
 from typing import Optional, cast, Iterator, Self
@@ -64,7 +64,7 @@ class Parameter:
     def logical_name(self) -> "Parameter":
         return self.get_attr(2)
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, Parameter):
             return cast("bool", self._value==other._value)
         return NotImplemented
@@ -115,12 +115,12 @@ class Parameter:
         """attribute or method index"""
         return self._value[7]
 
-    def get_attr(self, i: int) -> "Parameter":
+    def get_attr(self, i: int) -> Self:
         """get attribute"""
         val = Index.pack(0, i)
         return self.__class__(self._value[:6] + val)
 
-    def get_meth(self, i: int) -> "Parameter":
+    def get_meth(self, i: int) -> Self:
         """get method"""
         val = Index.pack(1, i)
         return self.__class__(self._value[:6] + val)
@@ -130,9 +130,9 @@ class Parameter:
         if len(self._value) == 6:
             tmp = self._value + val
         else:
-            tmp = bytearray(self._value)
-            tmp[6:8] = val
-            tmp = bytes(tmp)
+            tmp_ = bytearray(self._value)
+            tmp_[6:8] = val
+            tmp = bytes(tmp_)
         return self.__class__(tmp)
 
     def append_validate(self) -> None:
@@ -180,10 +180,12 @@ class Parameter:
     def piece(self) -> Optional[int]:
         if self.has_piece():
             return self._value[-1]
+        return None
 
     def clear_piece(self) -> "Parameter":
         if self.has_piece():
             return self.__class__(self._value[:-1])
+        return self
 
     def elements(self, start: int = 0) -> Iterator[int]:
         """return: index elements nested in attribute, started with"""
@@ -216,12 +218,12 @@ class Parameter:
         return max(0, (len(self._value) - 8) // 2)
 
     def set(self,
-            a: int = None,
-            b: int = None,
-            c: int = None,
-            d: int = None,
-            e: int = None,
-            f: int = None
+            a: Optional[int] = None,
+            b: Optional[int] = None,
+            c: Optional[int] = None,
+            d: Optional[int] = None,
+            e: Optional[int] = None,
+            f: Optional[int] = None
             ) -> "Parameter":
         val = bytearray(self._value)
         if a is not None:
@@ -238,12 +240,12 @@ class Parameter:
             val[5] = f
         return self.__class__(bytes(val))
 
-    def __contains__(self, item: "Parameter"):
+    def __contains__(self, item: "Parameter") -> bool:
         return item._value in self._value
 
-    def __getitem__(self, item) -> Optional[int]:
+    def __getitem__(self, item: int) -> Optional[int]:
         if self.n_elements > 0:
-            return unpack_from(">H", self._value, item * 2 + 8)[0]
+            return cast(int, unpack_from(">H", self._value, item * 2 + 8)[0])
         else:
             return None
 
@@ -296,12 +298,12 @@ class ParPattern:
     positions: tuple[int, ...]
     "7 elements , -1 is SKIP, last element is attribute index if positive and method index else negative"
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if 6 > len(self.positions) > 7:
             raise ValueError(f"positions must have exactly 6 elements, got {len(self.positions)}")
 
     @classmethod
-    def parse(cls, pattern: str) -> 'LNPattern':
+    def parse(cls, pattern: str) -> "ParPattern":
         """Парсинг строк вида:
         - "a.0.(1,2,3).(0-64).0.f" (6 элементов)
         - "a.0.1.0.0.f:2" (6 элементов + индекс через :)
@@ -379,7 +381,7 @@ class ParPattern:
     @staticmethod
     def _parse_group(group_str: str) -> set[int]:
         """Парсинг групп вида '1,2,3' или '10-20'"""
-        elements = set()
+        elements: set[int] = set()
         for item in group_str.split(','):
             item = item.strip()
             if '-' in item:
@@ -392,7 +394,7 @@ class ParPattern:
     # @functools.cache
     def __hash__(self) -> int:
         print("hash")
-        hash_parts = []
+        hash_parts: list[Optional[bytes]] = []
         for pos in self.positions:
             if pos == -1:
                 hash_parts.append(None)
@@ -475,9 +477,9 @@ class ParPattern:
 class PatternMatcher:
     """Класс для быстрого сопоставления Parameter с ParPattern"""
     patterns: dict['ParPattern', str]
-    _masks: list[tuple[tuple[np.ndarray, ...], str]] = None
+    _masks: list[tuple[tuple[np.ndarray, ...], str]] = field(init=False)
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         # Предварительная обработка шаблонов
         masks = []
         for pattern, value in self.patterns.items():

{dlms_spodes-0.87.1 → dlms_spodes-0.87.3}/src/DLMS_SPODES/cosem_interface_classes/parameters.py

@@ -12,11 +12,13 @@ class Data(Parameter):
 
 
 class ActiveFirmwareIdentifier(Data):
-    def from_b(self, b: int) -> "ActiveFirmwareIdentifier":
+
+    @classmethod
+    def from_b(cls, b: int = 0) -> "ActiveFirmwareIdentifier":
         return cls.parse(f"0.{b}.0.2.0.255")
 
 
-ACTIVE_FIRMWARE_IDENTIFIER_0 = ActiveFirmwareIdentifier.from_b(0)
+ACTIVE_FIRMWARE_IDENTIFIER_0 = ActiveFirmwareIdentifier.from_b()
 
 
 @dataclass(frozen=True)
@@ -26,6 +28,77 @@ class Register(Data):
         return self.get_attr(3)
 
 
+@dataclass(frozen=True)
+class Clock(Parameter):
+    @classmethod
+    def from_be(cls, b: int = 0, e: int = 0) -> "Clock":
+        return cls.parse(f"0.{b}.1.0.{e}.255")
+
+    @property
+    def time(self) -> "Clock":
+        return self.get_attr(2)
+
+    @property
+    def time_zone(self) -> "Clock":
+        return self.get_attr(3)
+
+    @property
+    def status(self) -> "Clock":
+        return self.get_attr(4)
+
+    @property
+    def time_zone(self) -> "Clock":
+        return self.get_attr(3)
+
+    @property
+    def status(self) -> "Clock":
+        return self.get_attr(4)
+
+    @property
+    def daylight_savings_begin(self) -> "Clock":
+        return self.get_attr(5)
+
+    @property
+    def daylight_savings_end(self) -> "Clock":
+        return self.get_attr(6)
+
+    @property
+    def daylight_savings_deviation(self) -> "Clock":
+        return self.get_attr(7)
+
+    @property
+    def daylight_savings_enabled(self) -> "Clock":
+        return self.get_attr(8)
+
+    @property
+    def clock_base(self) -> "Clock":
+        return self.get_attr(9)
+
+    @property
+    def adjust_to_quarter(self) -> "Clock":
+        return self.get_meth(1)
+
+    @property
+    def adjust_to_measuring_period(self) -> "Clock":
+        return self.get_meth(2)
+
+    @property
+    def adjust_to_minute(self) -> "Clock":
+        return self.get_meth(3)
+
+    @property
+    def adjust_to_preset_time(self) -> "Clock":
+        return self.get_meth(4)
+
+    @property
+    def preset_adjusting_time(self) -> "Clock":
+        return self.get_meth(5)
+
+    @property
+    def shift_time(self) -> "Clock":
+        return self.get_meth(6)
+
+
 @dataclass(frozen=True)
 class DisconnectControl(Parameter):
 

dlms_spodes-0.87.3/src/DLMS_SPODES/cosem_interface_classes/reports.py

@@ -0,0 +1,70 @@
+from typing import Any, Iterable
+from StructResult import result
+from . import cosem_interface_class as ic
+from ..types import cdt
+from .parameter import Parameter
+from ..cosem_interface_classes import collection
+from ..config_parser import get_values
+from ..settings import settings
+
+
+def from_obj(
+        col: collection.Collection,
+        obj: ic.COSEMInterfaceClasses,
+        attr_index_par: tuple[int, ...]
+) -> result.SimpleOrError[str]:
+    if not hasattr(from_obj, "struct_pattern"):
+        from_obj.struct_pattern = dict(settings.report.struct)
+    ret: str = F"[{collection.get_name(obj.logical_name)}]\n"
+    for i in attr_index_par:
+        par = Parameter(obj.logical_name.contents).set_i(i)
+        if isinstance(res_data := col.par2data(par), result.Error):
+            return res_data
+        a_data = res_data.value
+        if isinstance(a_data, cdt.SimpleDataType):
+            rep = col.par2rep(par, a_data)
+            ret += F"  {obj.get_attr_element(i)}: {rep.msg}{f" {rep.unit}" if rep.unit else ""}\n"
+        elif isinstance(a_data, cdt.ComplexDataType):
+            ret += F"  [{obj.get_attr_element(i)}]\n"
+            stack: list[tuple[Any, Any]] = [("", iter(a_data))]
+            while stack:
+                name, value_it = stack[-1]
+                indent = F"{' ' * (len(stack) + 1)}"
+                data = next(value_it, None)
+                if data:
+                    if not isinstance(name, str):
+                        name = str(next(name))
+                    if isinstance(data, cdt.Array):
+                        ret += F"{indent}[{name}]\n"
+                        stack.append(("*", iter(data)))
+                    elif isinstance(data, cdt.Structure):
+                        if (pattern := from_obj.struct_pattern.get(data.__class__.__name__)):
+                            val = list(pattern)
+                            val.reverse()
+                            result_ = str()
+                            while val:
+                                match val.pop():
+                                    case "%":
+                                        par_ = val.pop()
+                                        index = int(val.pop() + val.pop())
+                                        match par_:
+                                            case "n":
+                                                result_ += str(data.ELEMENTS[index])
+                                            case "v":
+                                                result_ += str(data[index])
+                                            case err:
+                                                raise ValueError(F"unknown macros &{err}{index}")
+                                    case symbol:
+                                        result_ += symbol
+                            ret += F"{indent}{result_}\n"
+                        else:
+                            if name=="":
+                                ret += "\n"
+                            else:
+                                ret += F"{indent}[{name}]\n"
+                            stack.append((iter(data.ELEMENTS), iter(data)))
+                    else:
+                        ret += F"{indent}{name}: {data}\n"
+                else:
+                    stack.pop()
+    return result.Simple(ret)

{dlms_spodes-0.87.1 → dlms_spodes-0.87.3}/src/DLMS_SPODES.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DLMS_SPODES
-Version: 0.87.1
+Version: 0.87.3
 Summary: dlms-spodes
 Author-email: Serj Kotilevski <youserj@outlook.com>
 Project-URL: Source, https://github.com/youserj/DlmsSPODES-project

dlms_spodes-0.87.1/src/DLMS_SPODES/cosem_interface_classes/reports.py

@@ -1,72 +0,0 @@
-from typing import Any
-from .collection import ic, cdt
-from ..cosem_interface_classes import collection
-from ..config_parser import get_values
-
-
-def get_obj_report(
-        obj: ic.COSEMInterfaceClasses,
-        attr_index_par: tuple[int | Any, ...]) -> str:
-    struct_report: dict | None = get_values("DLMS", "report", "struct")
-    ret = str()
-    ret += F"[{collection.get_name(obj.logical_name)}]\n"
-    for i in attr_index_par:
-        if isinstance(i, int):
-            pass
-        else:
-            i, par = i[0], i[1:]
-        value = obj.get_attr(i)
-        if isinstance(value, cdt.SimpleDataType):
-            match obj, i:
-                case collection.impl.data.DLMSDeviceIDObject(), 2: value = value.to_str()
-                case _: pass
-            if isinstance(value, cdt.OctetString):
-                pass
-            if hasattr(value, "report"):
-                value = value.report
-            ret += F"  {obj.get_attr_element(i)}: {value}\n"
-        elif isinstance(value, cdt.ComplexDataType):
-            ret += F"  [{obj.get_attr_element(i)}]\n"
-            stack: list = [("", iter(value))]
-            while stack:
-                name, value_it = stack[-1]
-                indent = F"{' '*(len(stack) + 1)}"
-                value = next(value_it, None)
-                if value:
-                    if not isinstance(name, str):
-                        name = next(name).NAME
-                    if isinstance(value, cdt.Array):
-                        ret += F"{indent}[{name}]\n"
-                        stack.append(("*", iter(value)))
-                    elif isinstance(value, cdt.Structure):
-                        if struct_report and (pattern := struct_report.get(value.__class__.__name__)):
-                            val = list(pattern)
-                            val.reverse()
-                            result = str()
-                            while val:
-                                i = val.pop()
-                                match i:
-                                    case "%":
-                                        par = val.pop()
-                                        index = int(val.pop() + val.pop())
-                                        match par:
-                                            case "n":
-                                                result += value.ELEMENTS[index].NAME
-                                            case "v":
-                                                result += str(value[index])
-                                            case err:
-                                                raise ValueError(F"unknown macros &{err}{index}")
-                                    case symbol:
-                                        result += symbol
-                            ret += F"{indent}{result}\n"
-                        else:
-                            if name == "":
-                                ret += "\n"
-                            else:
-                                ret += F"{indent}[{name}]\n"
-                            stack.append((iter(value.ELEMENTS), iter(value)))
-                    else:
-                        ret += F"{indent}{name}: {value}\n"
-                else:
-                    stack.pop()
-    return ret