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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DLMS_SPODES
-Version: 0.87.2
+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.2 → dlms_spodes-0.87.3}/pyproject.toml

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

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

@@ -14,11 +14,11 @@ class Data(Parameter):
 class ActiveFirmwareIdentifier(Data):
 
     @classmethod
-    def from_b(cls, b: int) -> "ActiveFirmwareIdentifier":
+    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)
@@ -28,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.2 → 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.2
+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.2/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