DLMS-SPODES 0.87.17__py3-none-any.whl → 0.88.1__py3-none-any.whl

DLMS_SPODES/cosem_interface_classes/reports.py

@@ -1,70 +1,72 @@
-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)
+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.IC,
+        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(res_a_el := obj.getAElement(i), result.Error):
+            return res_a_el
+        if isinstance(a_data, cdt.SimpleDataType):
+            rep = col.par2rep(par, a_data)
+            ret += F"  {res_a_el.value}: {rep.msg}{f" {rep.unit}" if rep.unit else ""}\n"
+        elif isinstance(a_data, cdt.ComplexDataType):
+            ret += F"  [{res_a_el.value}]\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/cosem_interface_classes/schedule.py

@@ -1,176 +1,88 @@
-from typing import Callable, Self
-from itertools import count
-from .__class_init__ import *
-from .overview import VERSION_0
-
-
-class Index(cdt.LongUnsigned, min=1, max=9999):
-    """ LongUnsigned type with validation """
-    __cb_get_indexes: Callable
-    DEFAULT = 1
-
-    def set_callback(self, cb: Callable):
-        self.__cb_get_indexes = cb
-
-    def get_indexes(self) -> list[int]:
-        """ return indexes container """
-        return self.__cb_get_indexes()
-
-    def check(self, string: str):
-        """ raise ValueError with message if string not is valid """
-        instance = type(self)(value=string)
-        if int(instance) in self.__cb_get_indexes():
-            raise ValueError('New index not unique')
-
-    @classmethod
-    def with_cb(cls, value, cb: Callable) -> Self:
-        """ get instance with callback """
-        ret = cls(value)
-        ret.set_callback(cb)
-        return ret
-
-
-class ScheduleTableEntry(cdt.Structure):
-    """ Specifies the scripts to be executed at given times. There is only one script that can be executed per entry. """
-    index: Index
-    enable: cdt.Boolean
-    script_logical_name: cst.LogicalName
-    script_selector: cdt.LongUnsigned
-    switch_time: cst.OctetStringTime
-    validity_window: cdt.LongUnsigned
-    exec_weekdays: cdt.BitString
-    exec_specdays: cdt.BitString
-    begin_date: cst.OctetStringDate
-    end_date: cst.OctetStringDate
-
-
-# TODO: rewrite to new API
-class Entries(cdt.Array):
-    """ Specifies the list of schedule_table_entry. Todo: validate by unique index"""
-    TYPE = ScheduleTableEntry
-    unique = True
-
-    def __init__(self, value: bytes = None):
-        super(Entries, self).__init__(value)
-        # setting callback for validate schedule_table_entry index
-        for schedule_table_entry in self:
-            schedule_table_entry: ScheduleTableEntry
-            schedule_table_entry.index.set_callback(self.get_indexes)
-
-    def get_indexes(self) -> list[int]:
-        """ getter for callback Index """
-        return [entries_element.index.decode() for entries_element in self]
-
-
-class DataED(cdt.Structure):
-    """ Sets the disabled bit of range A entries to true and then enables the entries of range B.
-    * firstIndexA/B < lastIndexA/B: all entries of the range A/B are disabled/enabled
-    * firstIndexA/B == lastIndexA/B: one entry is disabled/enabled,
-    * firstIndexA/B > lastIndexA/B: nothing disabled/enabled,
-    * firstIndexA/B and lastIndexA/B > 9999: no entry is disabled/enabled """
-    firstIndexA: Index
-    lastIndexA: Index
-    firstIndexB: Index
-    lastIndexB: Index
-
-
-class DataDelete(cdt.Structure):
-    """ Deletes a range of entries in the table.
-    * firstIndex < lastIndex: all entries of the range A/B are deleted,
-    * firstIndex ::= lastIndex: one entry is deleted,
-    * firstIndex > lastIndex: nothing deleted  """
-    firstIndex: Index
-    lastIndex: Index
-
-
-class Schedule(ic.COSEMInterfaceClasses):
-    """ The IC “Schedule” together with an object of the IC “Special days”  table handles time and date driven activities within a device.
-    The following picture gives an overview and shows the interactions between them:
-    Schedule:
-
-    Index | enable | action | Switch_time | validity_window |     exec_weekdays    |  exec_specdays  | date range
-          |        |(script)|             |                 | Mo Tu We Th Fr Sa Su | S1 S2 ... S8 S9 | begin_date | end_date
-    120     Yes     xxxx:yy     06:00           0xFFFF        x  x  x  x  x  x                         xx-04-01     xx-09-30
-    121     Yes     xxxx:yy     22:00            15           x  x  x  x  x                            xx-04-01     xx-09-30
-    122     Yes     xxxx:yy     12:00             0                          x                         xx-04-01     xx-09-30
-    200     No      xxxx:yy     06:30                         x  x  x  x  x  x                         xx-04-01     xx-09-30
-    201     No      xxxx:yy     21:30                         x  x  x  x  x                            xx-04-01     xx-09-30
-    202     No      xxxx:yy     11:00                                        x                         xx-04-01     xx-09-30
-
-    Special days table:
-
-    Index | special_day_date | day_id
-     12         xx-12-24        S1
-     33         xx-12-25        S3
-     77         97-03-31        S3
-
-     Recovery after power failure
-     After a power failure, the whole schedule is processed to execute all the necessary scripts that would get lost during a power failure. For this,
-     the entries that were not executed during the power failure must be detected. Depending on the validity window attribute they are executed in
-     the correct order (as they would have been executed in normal operation).
-
-     Handling of time changes
-     There are four different "actions" of time changes:
-        a) time setting forward; b) time setting backwards; c) time synchronization; d) daylight saving action.
-     All these four actions need a different handling executed by the schedule in interaction with the time setting activity.
-
-     Time setting forward*
-     This is handled the same way as a power failure. All entries missed are executed depending on the validity window attribute.
-     A (manufacturer specific defined) short time setting can be handled like time synchronization.
-     * Writing to the attribute “time” of the “Clock” object.
-
-     Time setting backward*
-     This results in a repetition of those entries that are activated during the repeated time. A (manufacturer specific defined) short time setting
-     can be handled like time synchronization.
-     * Writing to the attribute “time” of the “Clock” object.
-
-     Time synchronization*
-     Time synchronization is used to correct small deviations between a master clock and the local clock. The algorithm is manufacturer specific.
-     It shall guarantee that no entry of the schedule gets lost, or is executed twice. The validity window attribute has no effect, because all
-     entries must be executed in normal operation.
-     * Using the method “adjust_to_quarter” of the “Clock” object.
-
-     Daylight saving
-     If the clock is put forward, then all scripts, which fall into the forwarding interval (and would therefore get lost) are executed.
-     If the clock is put back, re-execution of the scripts, which fall into the backwarding interval is suppressed. """
-    CLASS_ID = ClassID.SCHEDULE
-    VERSION = VERSION_0
-    A_ELEMENTS = ic.ICAElement("entries", Entries),
-    M_ELEMENTS = (ic.ICMElement("enable_disable", DataED),
-                  ic.ICMElement("insert", ScheduleTableEntry),
-                  ic.ICMElement("delete", DataDelete))
-
-    def characteristics_init(self):
-        self.set_attr(2, None)
-        self._cbs_attr_post_init.update({2: self.__set_index_cbs})
-
-    @property
-    def entries(self) -> Entries:
-        return self.get_attr(2)
-
-    @property
-    def enable_disable(self) -> DataED:
-        return self.get_meth(1)
-
-    @property
-    def insert(self) -> ScheduleTableEntry:
-        return self.get_meth(2)
-
-    @property
-    def delete(self) -> DataDelete:
-        return self.get_meth(3)
-
-    def __set_index_cbs(self):
-        """ set callbacks to methods """
-        try:
-            indexes: Callable = self.entries.get_indexes
-            self.enable_disable.firstIndexA.set_callback(indexes)
-            self.enable_disable.firstIndexB.set_callback(indexes)
-            self.enable_disable.lastIndexA.set_callback(indexes)
-            self.enable_disable.lastIndexB.set_callback(indexes)
-            self.insert.index.set_callback(indexes)
-            self.delete.firstIndex.set_callback(indexes)
-            self.delete.lastIndex.set_callback(indexes)
-            # print('set delete')
-        except KeyError:  # At init time
-            print('set delete NO:')
+from typing import Callable, Self
+from .cosem_interface_class import ICAuto, ICAElement, ICMElement
+from .Overview import class_id
+from ..types import cdt, cst
+from ..types.type_alias import Attr
+
+
+class Index(cdt.LongUnsigned, min=1, max=9999):
+    """ LongUnsigned type with validation """
+    __cb_get_indexes: Callable
+    DEFAULT = 1
+
+    def set_callback(self, cb: Callable):
+        self.__cb_get_indexes = cb
+
+    def get_indexes(self) -> list[int]:
+        """ return indexes container """
+        return self.__cb_get_indexes()
+
+    def check(self, string: str):
+        """ raise ValueError with message if string not is valid """
+        instance = type(self)(value=string)
+        if int(instance) in self.__cb_get_indexes():
+            raise ValueError('New index not unique')
+
+    @classmethod
+    def with_cb(cls, value, cb: Callable) -> Self:
+        """ get instance with callback """
+        ret = cls(value)
+        ret.set_callback(cb)
+        return ret
+
+
+class ScheduleTableEntry(cdt.Structure):
+    """schedule_table_entry"""
+    index: Index
+    enable: cdt.Boolean
+    script_logical_name: cst.LogicalName
+    script_selector: cdt.LongUnsigned
+    switch_time: cst.OctetStringTime
+    validity_window: cdt.LongUnsigned
+    exec_weekdays: cdt.BitString
+    exec_specdays: cdt.BitString
+    begin_date: cst.OctetStringDate
+    end_date: cst.OctetStringDate
+
+
+# TODO: rewrite to new API
+class Entries(cdt.Array):
+    """entries attribute"""
+    TYPE = ScheduleTableEntry
+    unique = True
+
+    def __init__(self, value: bytes = None):
+        super(Entries, self).__init__(value)
+        # setting callback for validate schedule_table_entry index
+        for schedule_table_entry in self:
+            schedule_table_entry: ScheduleTableEntry
+            schedule_table_entry.index.set_callback(self.get_indexes)
+
+    def get_indexes(self) -> list[int]:
+        """ getter for callback Index """
+        return [entries_element.index.decode() for entries_element in self]
+
+
+class DataED(cdt.Structure):
+    """ enable/disable"""
+    firstIndexA: Index
+    lastIndexA: Index
+    firstIndexB: Index
+    lastIndexB: Index
+
+
+class DataDelete(cdt.Structure):
+    """delete"""
+    firstIndex: Index
+    lastIndex: Index
+
+
+class Schedule(ICAuto):
+    """4.5.3 Schedule"""
+    CLASS_ID = class_id.SCHEDULE
+    VERSION = 0
+    A_ELEMENTS = ICAElement(2, "entries", Entries),
+    M_ELEMENTS = (ICMElement(1, "enable_disable", DataED),
+                  ICMElement(2, "insert", ScheduleTableEntry),
+                  ICMElement(3, "delete", DataDelete))
+    entries: Attr

DLMS_SPODES/cosem_interface_classes/script_table.py

@@ -1,87 +1,54 @@
-from .__class_init__ import *
-from ..types import choices
-from .overview import VERSION_0
-
-
-class ServiceId(cdt.Enum, elements=(1, 2)):
-    """defines which action to be applied to the referenced object."""
-
-
-class ActionSpecification(cdt.Structure):
-    """ Specifies the different scripts, i.e. the lists of actions. The first attribute (logical_name) has index 1, the first specific method has
-    index 1 as well. NOTE The action_specification is limited to activate methods that do not produce any response (from the server to the client). """
-    service_id: ServiceId
-    class_id: cdt.LongUnsigned
-    logical_name: cst.LogicalName
-    index: cdt.Integer
-    parameter: choices.common_dt
-
-
-class Actions(cdt.Array):
-    """ Specifies the list of action specification """
-    TYPE = ActionSpecification
-
-
-class Script(cdt.Structure):
-    """ Specifies the different scripts. The script_identifier 0 is reserved. If specified with an execute method, it results in a null script (no actions to perform)"""
-    script_identifier: cdt.LongUnsigned
-    actions: Actions
-
-
-class Scripts(cdt.Array):
-    """ Specifies the lists of actions """
-    TYPE = Script
-    __get_item__: Script
-
-    def new_element(self) -> Script:
-        """return default Script with vacant script_identifier"""
-        # todo: make common function by ID element
-        el: Script
-        day_ids: list[int] = [int(el.script_identifier) for el in self.values]
-        for i in range(0xffff):
-            if i not in day_ids:
-                return Script((i, None))
-        raise ValueError(F"in {self} all <script_identifier> is busy")
-
-
-class ScriptTable(ic.COSEMInterfaceClasses):
-    """Script table"""
-    CLASS_ID = ClassID.SCRIPT_TABLE
-    VERSION = VERSION_0
-    A_ELEMENTS = ic.ICAElement("scripts", Scripts),
-    M_ELEMENTS = ic.ICMElement("execute", cdt.LongUnsigned),
-
-    def characteristics_init(self):
-        self.set_attr(2, None)
-        self._cbs_attr_post_init.update({2: self.__set_script_identifier_cbs})
-
-    @property
-    def scripts(self) -> Scripts:
-        return self.get_attr(2)
-
-    @property
-    def execute(self) -> cdt.LongUnsigned:
-        return self.get_meth(1)
-
-    def __set_script_identifier_cbs(self):
-        pass
-        # try:
-        #     indexes: Callable = self.entries.get_indexes
-        #     self.enable_disable.firstIndexA.set_callback(indexes)
-        #     self.enable_disable.firstIndexB.set_callback(indexes)
-        #     self.enable_disable.lastIndexA.set_callback(indexes)
-        #     self.enable_disable.lastIndexB.set_callback(indexes)
-        #     self.insert.index.set_callback(indexes)
-        #     self.delete.firstIndex.set_callback(indexes)
-        #     self.delete.lastIndex.set_callback(indexes)
-        #     print('set delete')
-        # except KeyError:  # At init time
-        #     print('set delete NO:')
-
-
-if __name__ == '__main__':
-    a = b'\x01\x04\x02\x02\x12\x00\x01\x01\x01\x02\x05\x16\x01\x12\x00F\t\x06\x00\x00`\x03\n\xff\x0f\x04\x16\x00\x02\x02\x12\x00\x02\x01\x01\x02\x05\x16\x02\x12\x00F\t\x06\x00\x00`\x03\n\xff\x0f\x01\x03\x00\x02\x02\x12\x00\x03\x01\x01\x02\x05\x16\x01\x12\x00F\t\x06\x00\x00`\x03\n\xff\x0f\x04\x16\x01\x02\x02\x12\x00\x04\x01\x01\x02\x05\x16\x02\x12\x00F\t\x06\x00\x00`\x03\n\xff\x0f\x01\x03\x01'
-    b = Scripts(a)
-    a = ScriptTable('0.0.10.0.0.255')
-    pass
-    print(a)
+from ..types import choices, cdt, cst
+from ..types.type_alias import Attr
+from .cosem_interface_class import ICAuto, ICAElement, ICMElement
+from .Overview import class_id
+
+
+class ServiceId(cdt.Enum, elements=(1, 2)):
+    """defines which action to be applied to the referenced object."""
+
+
+class ActionSpecification(cdt.Structure):
+    """ Specifies the different scripts, i.e. the lists of actions. The first attribute (logical_name) has index 1, the first specific method has
+    index 1 as well. NOTE The action_specification is limited to activate methods that do not produce any response (from the server to the client). """
+    service_id: ServiceId
+    class_id: cdt.LongUnsigned
+    logical_name: cst.LogicalName
+    index: cdt.Integer
+    parameter: choices.common_dt
+
+
+class Actions(cdt.Array):
+    """ Specifies the list of action specification """
+    TYPE = ActionSpecification
+
+
+class Script(cdt.Structure):
+    """ Specifies the different scripts. The script_identifier 0 is reserved. If specified with an execute method, it results in a null script (no actions to perform)"""
+    script_identifier: cdt.LongUnsigned
+    actions: Actions
+
+
+class Scripts(cdt.Array):
+    """ Specifies the lists of actions """
+    TYPE = Script
+    __get_item__: Script
+
+    def new_element(self) -> Script:
+        """return default Script with vacant script_identifier"""
+        # todo: make common function by ID element
+        el: Script
+        day_ids: list[int] = [int(el.script_identifier) for el in self.values]
+        for i in range(0xffff):
+            if i not in day_ids:
+                return Script((i, None))
+        raise ValueError(F"in {self} all <script_identifier> is busy")
+
+
+class ScriptTable(ICAuto):
+    """Script table"""
+    CLASS_ID = class_id.SCRIPT_TABLE
+    VERSION = 0
+    A_ELEMENTS = ICAElement(2, "scripts", Scripts),
+    M_ELEMENTS = ICMElement(1, "execute", cdt.LongUnsigned),
+    scripts: Attr