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

DLMS_SPODES/cosem_interface_classes/data.py

@@ -1,21 +1,12 @@
-from __future__ import annotations
-from ..types import choices
-from . import cosem_interface_class as ic
-from .overview import ClassID
-from .overview import VERSION_0
-
-
-class Data(ic.COSEMInterfaceClasses):
-    """ Object stores data related to internal meter object(s). The meaning of the value is identified by the logical_name.
-    The data type of the value is CHOICE. “Data” is typically used to store configuration data and parameters """
-    CLASS_ID = ClassID.DATA
-    VERSION = VERSION_0
-    A_ELEMENTS = ic.ICAElement("value", choices.common_dt, classifier=ic.Classifier.NOT_SPECIFIC),
-
-    def characteristics_init(self):
-        """nothing do it"""
-
-    @property
-    def value(self) -> cdt.CommonDataTypes:
-        """Contains the data"""
-        return self.get_attr(2)
+from typing import Optional
+from ..types import choices, cdt
+from .cosem_interface_class import ICAuto, ICAElement, Classifier
+from .Overview import class_id
+
+
+class Data(ICAuto):
+    """4.3.1 Data"""
+    CLASS_ID = class_id.DATA
+    VERSION = 0
+    A_ELEMENTS = ICAElement(2, "value", choices.common_dt, classifier=Classifier.NOT_SPECIFIC),
+    value: Optional[cdt.CommonDataTypes]

DLMS_SPODES/cosem_interface_classes/demand_register/ver0.py

@@ -1,59 +1,32 @@
-from ..__class_init__ import *
-from ...types import choices
-from ...types.implementations import integers
-from ..overview import VERSION_0
-
-
-class DemandRegister(ic.COSEMInterfaceClasses):
-    """DLMS UA 1000-1 Ed 14 4.3.4.Demand register"""
-    CLASS_ID = ClassID.DEMAND_REGISTER
-    VERSION = VERSION_0
-    A_ELEMENTS = (
-        ic.ICAElement("current_average_value", choices.register, classifier=ic.Classifier.DYNAMIC),
-        ic.ICAElement("last_average_value", choices.register, classifier=ic.Classifier.DYNAMIC),
-        ic.ICAElement("scaler_unit", cdt.ScalUnitType),
-        ic.ICAElement("status", choices.extended_register, classifier=ic.Classifier.DYNAMIC),
-        ic.ICAElement("capture_time", cst.OctetStringDateTime, classifier=ic.Classifier.DYNAMIC),
-        ic.ICAElement("start_time_current", cst.OctetStringDateTime, classifier=ic.Classifier.DYNAMIC),
-        ic.ICAElement("period", cdt.DoubleLongUnsigned, min=1),
-        ic.ICAElement("number_of_periods", cdt.LongUnsigned, min=1, default=1))
-    M_ELEMENTS = (
-        ic.ICMElement("reset", integers.Only0),
-        ic.ICMElement("next_period", integers.Only0))
-    scaler_unit_not_settable: bool
-
-    @property
-    def current_average_value(self) -> choices.RegisterValues:
-        return self.get_attr(2)
-
-    @property
-    def last_average_value(self) -> choices.RegisterValues:
-        return self.get_attr(3)
-
-    @property
-    def scaler_unit(self) -> cdt.ScalUnitType:
-        return self.get_attr(4)
-
-    @property
-    def status(self) -> choices.ExtendedRegisterValues:
-        return self.get_attr(5)
-
-    @property
-    def capture_time(self) -> cst.OctetStringDateTime:
-        return self.get_attr(6)
-
-    @property
-    def start_time_current(self) -> cst.OctetStringDateTime:
-        return self.get_attr(7)
-
-    @property
-    def period(self) -> cdt.DoubleLongUnsigned:
-        return self.get_attr(8)
-
-    @property
-    def number_of_periods(self) -> cdt.LongUnsigned:
-        return self.get_attr(9)
-
-    def characteristics_init(self):
-        self.scaler_unit_not_settable = False
-        """ usability scaler unit flag. if True then it not used"""
+from ...types import choices, cdt, cst
+from ...types.implementations import integers
+from ...types.type_alias import Attr
+from ..cosem_interface_class import ICAuto, ICAElement, ICMElement, Classifier, Cardinality
+from ..Overview import class_id
+
+
+class DemandRegister(ICAuto):
+    """4.3.4.Demand register"""
+    CLASS_ID = class_id.DEMAND_REGISTER
+    VERSION = 0
+    CARDINALITY = Cardinality()
+    A_ELEMENTS = (
+        ICAElement(2, "current_average_value", choices.register, classifier=Classifier.DYNAMIC),
+        ICAElement(3, "last_average_value", choices.register, classifier=Classifier.DYNAMIC),
+        ICAElement(4, "scaler_unit", cdt.ScalUnitType),
+        ICAElement(5, "status", choices.extended_register, classifier=Classifier.DYNAMIC),
+        ICAElement(6, "capture_time", cst.OctetStringDateTime, classifier=Classifier.DYNAMIC),
+        ICAElement(7, "start_time_current", cst.OctetStringDateTime, classifier=Classifier.DYNAMIC),
+        ICAElement(8, "period", cdt.DoubleLongUnsigned, min=1),
+        ICAElement(9, "number_of_periods", cdt.LongUnsigned, min=1, default=1))
+    M_ELEMENTS = (
+        ICMElement(1, "reset", integers.Only0),
+        ICMElement(2, "next_period", integers.Only0))
+    current_average_value: Attr
+    last_average_value: Attr
+    scaler_unit: Attr
+    status: Attr
+    capture_time: Attr
+    start_time_current: Attr
+    period: Attr
+    number_of_periods: Attr

DLMS_SPODES/cosem_interface_classes/disconnect_control.py

@@ -1,74 +1,56 @@
-from .__class_init__ import *
-from ..types.implementations import integers
-from itertools import chain
-from ..config_parser import get_message
-from .overview import VERSION_0
-
-
-class ControlState(cdt.Enum, elements=(0, 1, 2)):
-    """ Shows the internal state of the disconnect control object. """
-
-
-class ControlMode(cdt.Enum, elements=tuple(chain(range(7), range(129, 135)))):
-    """ Configures the behaviour of the disconnect control object for all triggers. Local disconnection is always possible.
-    To suppress local disconnection, the corresponding trigger must be inhibited. """
-
-    @staticmethod
-    def get_letters(value: int) -> str:
-        """return transition litters"""
-        match value:
-            case 0:   return ""
-            case 1:   return "bcfgde"
-            case 2:   return "bcfgae"
-            case 3:   return "bcgde"
-            case 4:   return "bcgae"
-            case 5:   return "bcfgdeh"
-            case 6:   return "bcgdeh"
-            case 129: return "bcfmde"
-            case 130: return "bcfmae"
-            case 131: return "bcmde"
-            case 132: return "bcma"
-            case 133: return "bcmak"
-            case 134: return "bcmsdep"
-            case _:   raise ValueError(F"unknown {value=}")
-
-
-class OutputState(cdt.Boolean):
-    """ Shows the actual physical state of the disconnect unit, i.e. if an electricity breaker or a gas valve is open or closed. TRUE = connected, FALSE = disconnected.
-    In electricity metering, the supply is connected when the disconnector device is closed. In gas and water metering, the supply is connected when the valve is open """
-    def __str__(self):
-        return get_message("$disconnected$") if self.contents == b'\x00' else get_message("$connected$")
-
-
-class DisconnectControl(ic.COSEMInterfaceClasses):
-    """DLMS UA 1000-1 Ed. 14 4.5.8 Disconnect control"""
-    CLASS_ID = ClassID.DISCONNECT_CONTROL
-    VERSION = VERSION_0
-    A_ELEMENTS = (ic.ICAElement("output_state", OutputState, classifier=ic.Classifier.DYNAMIC),
-                  ic.ICAElement("control_state", ControlState, classifier=ic.Classifier.DYNAMIC),
-                  ic.ICAElement("control_mode", ControlMode))
-    M_ELEMENTS = (ic.ICMElement("remote_disconnect", integers.Only0),
-                  ic.ICMElement("remote_reconnect", integers.Only0))
-
-    def characteristics_init(self):
-        """nothing do it"""
-
-    @property
-    def output_state(self) -> cdt.Boolean:
-        return self.get_attr(2)
-
-    @property
-    def control_state(self) -> ControlState:
-        return self.get_attr(3)
-
-    @property
-    def control_mode(self) -> ControlMode:
-        return self.get_attr(4)
-
-    @property
-    def remote_disconnect(self) -> cdt.Integer:
-        return self.get_meth(1)
-
-    @property
-    def remote_reconnect(self) -> cdt.Integer:
-        return self.get_meth(2)
+from itertools import chain
+from ..config_parser import get_message
+from ..types.implementations import integers
+from typing import Optional
+from ..types import cdt
+from .cosem_interface_class import ICAElement, ICMElement, Classifier, ICAuto
+from .Overview import class_id
+
+
+class ControlState(cdt.Enum, elements=(0, 1, 2)):
+    """ Shows the internal state of the disconnect control object. """
+
+
+class ControlMode(cdt.Enum, elements=tuple(chain(range(7), range(129, 135)))):
+    """ Configures the behaviour of the disconnect control object for all triggers. Local disconnection is always possible.
+    To suppress local disconnection, the corresponding trigger must be inhibited. """
+
+    @staticmethod
+    def get_letters(value: int) -> str:
+        """return transition litters"""
+        match value:
+            case 0:   return ""
+            case 1:   return "bcfgde"
+            case 2:   return "bcfgae"
+            case 3:   return "bcgde"
+            case 4:   return "bcgae"
+            case 5:   return "bcfgdeh"
+            case 6:   return "bcgdeh"
+            case 129: return "bcfmde"
+            case 130: return "bcfmae"
+            case 131: return "bcmde"
+            case 132: return "bcma"
+            case 133: return "bcmak"
+            case 134: return "bcmsdep"
+            case _:   raise ValueError(F"unknown {value=}")
+
+
+class OutputState(cdt.Boolean):
+    """ Shows the actual physical state of the disconnect unit, i.e. if an electricity breaker or a gas valve is open or closed. TRUE = connected, FALSE = disconnected.
+    In electricity metering, the supply is connected when the disconnector device is closed. In gas and water metering, the supply is connected when the valve is open """
+    def __str__(self):
+        return get_message("$disconnected$") if self.contents == b'\x00' else get_message("$connected$")
+
+
+class DisconnectControl(ICAuto):
+    """4.5.8 Disconnect control"""
+    CLASS_ID = class_id.DISCONNECT_CONTROL
+    VERSION = 0
+    A_ELEMENTS = (ICAElement(2, "output_state", OutputState, classifier=Classifier.DYNAMIC),
+                  ICAElement(3, "control_state", ControlState, classifier=Classifier.DYNAMIC),
+                  ICAElement(4, "control_mode", ControlMode))
+    M_ELEMENTS = (ICMElement(1, "remote_disconnect", integers.Only0),
+                  ICMElement(2, "remote_reconnect", integers.Only0))
+    output_state: Optional[cdt.Boolean]
+    control_state: Optional[ControlState]
+    control_mode: Optional[ControlMode]

DLMS_SPODES/cosem_interface_classes/extended_register.py

@@ -1,27 +1,18 @@
-from . import register
-from .__class_init__ import *
-from ..types import choices
-from .overview import VERSION_0
-
-
-class ExtendedRegister(register.Register, ic.COSEMInterfaceClasses):
-    """ A “Register” object stores a process value or a status value with its associated unit. The register object knows
-    the nature of the process value or of the status value. The nature of the value is described by the attribute
-    “logical name” using the OBIS identification system. """
-    CLASS_ID = ClassID.EXT_REGISTER
-    VERSION = VERSION_0
-    A_ELEMENTS = (register.Register.get_attr_element(2),
-                  register.Register.get_attr_element(3),
-                  ic.ICAElement("status", choices.extended_register, classifier=ic.Classifier.DYNAMIC),
-                  ic.ICAElement("capture_time", cst.OctetStringDateTime, classifier=ic.Classifier.DYNAMIC))
-    M_ELEMENTS = register.Register.get_meth_element(1),
-
-    @property
-    def status(self) -> choices.ExtendedRegisterValues:
-        return self.get_attr(4)
-
-    @property
-    def capture_time(self) -> cdt.DateTime:
-        return self.get_attr(5)
-
-
+from . import register
+from typing import Optional
+from ..types import choices, cdt, cst
+from .cosem_interface_class import ICAElement, Classifier
+from .Overview import class_id
+
+
+class ExtendedRegister(register.Register):
+    """4.3.3 Extended register"""
+    CLASS_ID = class_id.EXT_REGISTER
+    VERSION = 0
+    A_ELEMENTS = (register.Register.getAElement(2).unwrap(),
+                  register.Register.getAElement(3).unwrap(),
+                  ICAElement(4, "status", choices.extended_register, classifier=Classifier.DYNAMIC),
+                  ICAElement(5, "capture_time", cst.OctetStringDateTime, classifier=Classifier.DYNAMIC))
+    M_ELEMENTS = register.Register.getMElement(1).unwrap(),
+    status: Optional[choices.ExtendedRegisterValues]
+    capture_time: Optional[cdt.DateTime]

DLMS_SPODES/cosem_interface_classes/gprs_modem_setup.py

@@ -1,43 +1,33 @@
-from . __class_init__ import *
-from .overview import VERSION_0
-
-
-class QoSElement(cdt.Structure):
-    """ Params of element """
-    precedence: cdt.Unsigned
-    delay: cdt.Unsigned
-    reliability: cdt.Unsigned
-    peak_throughput: cdt.Unsigned
-    mean_throughput: cdt.Unsigned
-
-
-class QualityOfService(cdt.Structure):
-    """ Specifies the quality of service parameters. It is a structure of 2 elements:
-            1: defines the default or minimum characteristics of the network concerned. These parameters have to be set to best effort value;
-            2: defines the requested parameters. """
-    default: QoSElement
-    requested: QoSElement
-
-
-class GPRSModemSetup(ic.COSEMInterfaceClasses):
-    """ This IC allow setting up GPRS modems, by handling all data necessary data for modem management. """
-    CLASS_ID = ClassID.GPRS_MODEM_SETUP
-    VERSION = VERSION_0
-    A_ELEMENTS = (ic.ICAElement("APN", cdt.OctetString),
-                  ic.ICAElement("PIN_code", cdt.LongUnsigned),
-                  ic.ICAElement("quality_of_service", QualityOfService))
-
-    def characteristics_init(self):
-        """nothing do it"""
-
-    @property
-    def APN(self) -> cdt.OctetString:
-        return self.get_attr(2)
-
-    @property
-    def PIN_code(self) -> cdt.LongUnsigned:
-        return self.get_attr(3)
-
-    @property
-    def quality_of_service(self) -> QualityOfService:
-        return self.get_attr(4)
+from typing import Optional
+from ..types import cdt
+from .cosem_interface_class import ICAElement, ICAuto
+from .Overview import class_id
+
+
+class QoSElement(cdt.Structure):
+    """ Params of element """
+    precedence: cdt.Unsigned
+    delay: cdt.Unsigned
+    reliability: cdt.Unsigned
+    peak_throughput: cdt.Unsigned
+    mean_throughput: cdt.Unsigned
+
+
+class QualityOfService(cdt.Structure):
+    """ Specifies the quality of service parameters. It is a structure of 2 elements:
+            1: defines the default or minimum characteristics of the network concerned. These parameters have to be set to best effort value;
+            2: defines the requested parameters. """
+    default: QoSElement
+    requested: QoSElement
+
+
+class GPRSModemSetup(ICAuto):
+    """ This IC allow setting up GPRS modems, by handling all data necessary data for modem management. """
+    CLASS_ID = class_id.GPRS_MODEM_SETUP
+    VERSION = 0
+    A_ELEMENTS = (ICAElement(2, "APN", cdt.OctetString),
+                  ICAElement(3, "PIN_code", cdt.LongUnsigned),
+                  ICAElement(4, "quality_of_service", QualityOfService))
+    APN: Optional[cdt.OctetString]
+    PIN_code: Optional[cdt.LongUnsigned]
+    quality_of_service: Optional[QualityOfService]

DLMS_SPODES/cosem_interface_classes/gsm_diagnostic/ver0.py

@@ -1,103 +1,78 @@
-import logging
-
-from ..__class_init__ import *
-from ...config_parser import get_message
-from ..overview import VERSION_0
-
-
-class Status(cdt.Enum, elements=tuple(range(6))):
-    """ Indicates the registration status of the  modem. """
-
-
-class CSAttachment(cdt.Enum, elements=(0, 1, 2)):
-    """ Indicates the current circuit switched status."""
-
-
-class PSStatus(cdt.Enum, elements=tuple(range(5))):
-    """ Indicates the packet switched status of the modem. """
-
-
-class SignalQuality(cdt.IntegerEnum, cdt.Unsigned):
-    """for string report"""
-    def __init_subclass__(cls, **kwargs):
-        """not need"""
-
-    def get_report(self) -> cdt.Report:
-        val = int(self)
-        if val == 0:
-            return cdt.Report(get_message(F"({val}) –113 dBm $or$ $less$(0)"))
-        elif val == 1:
-            return cdt.Report(F"({val}) –111 dBm")
-        elif val < 31:
-            return cdt.Report(get_message(F"({val}) {-109+(val-2)*2} dBm"))
-        elif val == 31:
-            return cdt.Report(get_message(F"({val}) –51 dBm $or$ $greater$"))
-        elif val == 99:
-            return cdt.Report(get_message(F"({val}) $not_known_or_not_detectable$"))
-        else:
-            return cdt.Report(
-                msg=F"({val})",
-                log=cdt.Log(logging.WARN, "unknown value"))
-
-
-class CellInfoType(cdt.Structure):
-    """ Params of element """
-    cell_ID: cdt.LongUnsigned
-    location_ID: cdt.LongUnsigned
-    signal_quality: SignalQuality
-    ber: cdt.Unsigned
-
-
-class AdjacentCellInfo(cdt.Structure):
-    cell_ID: cdt.LongUnsigned
-    signal_quality: SignalQuality
-
-
-class AdjacentCells(cdt.Array):
-    TYPE = AdjacentCellInfo
-
-
-class GSMDiagnostic(ic.COSEMInterfaceClasses):
-    """ The GSM/GPRS network is undergoing constant changes in terms of registration status, signal quality etc. It is necessary to monitor and log the relevant parameters in order
-     to obtain diagnostic information that allows identifying communication problems in the network. An instance of the 'GSM diagnostic' class stores parameters of the GSM/GPRS
-     network necessary for analysing the operation of the network."""
-    CLASS_ID = ClassID.GSM_DIAGNOSTIC
-    VERSION = VERSION_0
-    A_ELEMENTS = (ic.ICAElement("operator", cdt.VisibleString, classifier=ic.Classifier.DYNAMIC),
-                  ic.ICAElement("status", Status, 0, 255, 0, classifier=ic.Classifier.DYNAMIC),
-                  ic.ICAElement("cs_attachment", CSAttachment, 0, 255, 0, classifier=ic.Classifier.DYNAMIC),
-                  ic.ICAElement("ps_status", PSStatus, 0, 255, 0, classifier=ic.Classifier.DYNAMIC),
-                  ic.ICAElement("cell_info", CellInfoType, classifier=ic.Classifier.DYNAMIC),
-                  ic.ICAElement("adjacent_cell", AdjacentCells, classifier=ic.Classifier.DYNAMIC),
-                  ic.ICAElement("capture_time", cdt.DateTime, classifier=ic.Classifier.DYNAMIC))
-
-    def characteristics_init(self):
-        """nothing do it"""
-
-    @property
-    def operator(self) -> cdt.VisibleString:
-        return self.get_attr(2)
-
-    @property
-    def status(self) -> Status:
-        return self.get_attr(3)
-
-    @property
-    def cs_attachment(self) -> CSAttachment:
-        return self.get_attr(4)
-
-    @property
-    def ps_status(self) -> PSStatus:
-        return self.get_attr(5)
-
-    @property
-    def cell_info(self) -> CellInfoType:
-        return self.get_attr(6)
-
-    @property
-    def adjacent_cell(self) -> AdjacentCells:
-        return self.get_attr(7)
-
-    @property
-    def capture_time(self) -> cdt.DateTime:
-        return self.get_attr(8)
+import logging
+from ...config_parser import get_message
+from typing import Optional
+from ...types import cdt
+from ..cosem_interface_class import ICAuto, ICAElement, Classifier
+from ..Overview import class_id
+
+
+class Status(cdt.Enum, elements=tuple(range(6))):
+    """ Indicates the registration status of the  modem. """
+
+
+class CSAttachment(cdt.Enum, elements=(0, 1, 2)):
+    """ Indicates the current circuit switched status."""
+
+
+class PSStatus(cdt.Enum, elements=tuple(range(5))):
+    """ Indicates the packet switched status of the modem. """
+
+
+class SignalQuality(cdt.IntegerEnum, cdt.Unsigned):
+    """for string report"""
+    def __init_subclass__(cls, **kwargs):
+        """not need"""
+
+    def get_report(self) -> cdt.Report:
+        val = int(self)
+        if val == 0:
+            return cdt.Report(get_message(F"({val}) –113 dBm $or$ $less$(0)"))
+        elif val == 1:
+            return cdt.Report(F"({val}) –111 dBm")
+        elif val < 31:
+            return cdt.Report(get_message(F"({val}) {-109+(val-2)*2} dBm"))
+        elif val == 31:
+            return cdt.Report(get_message(F"({val}) –51 dBm $or$ $greater$"))
+        elif val == 99:
+            return cdt.Report(get_message(F"({val}) $not_known_or_not_detectable$"))
+        else:
+            return cdt.Report(
+                msg=F"({val})",
+                log=cdt.Log(logging.WARN, "unknown value"))
+
+
+class CellInfoType(cdt.Structure):
+    """ Params of element """
+    cell_ID: cdt.LongUnsigned
+    location_ID: cdt.LongUnsigned
+    signal_quality: SignalQuality
+    ber: cdt.Unsigned
+
+
+class AdjacentCellInfo(cdt.Structure):
+    cell_ID: cdt.LongUnsigned
+    signal_quality: SignalQuality
+
+
+class AdjacentCells(cdt.Array):
+    TYPE = AdjacentCellInfo
+
+
+class GSMDiagnostic(ICAuto):
+    """4.7.8 GSM diagnostic"""
+    CLASS_ID = class_id.GSM_DIAGNOSTIC
+    VERSION = 0
+    A_ELEMENTS = (ICAElement(2, "operator", cdt.VisibleString, classifier=Classifier.DYNAMIC),
+                  ICAElement(3, "status", Status, 0, 255, 0, classifier=Classifier.DYNAMIC),
+                  ICAElement(4, "cs_attachment", CSAttachment, 0, 255, 0, classifier=Classifier.DYNAMIC),
+                  ICAElement(5, "ps_status", PSStatus, 0, 255, 0, classifier=Classifier.DYNAMIC),
+                  ICAElement(6, "cell_info", CellInfoType, classifier=Classifier.DYNAMIC),
+                  ICAElement(7, "adjacent_cell", AdjacentCells, classifier=Classifier.DYNAMIC),
+                  ICAElement(8, "capture_time", cdt.DateTime, classifier=Classifier.DYNAMIC))
+    operator: Optional[cdt.VisibleString]
+    status: Optional[Status]
+    cs_attachment: Optional[CSAttachment]
+    ps_status: Optional[PSStatus]
+    cell_info: Optional[CellInfoType]
+    adjacent_cell: Optional[AdjacentCells]
+    capture_time: Optional[cdt.DateTime]