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

DLMS_SPODES/types/cosem_service_types.py

@@ -1,109 +1,109 @@
-from typing import Self
-import re
-from ..types import common_data_types as cdt
-import datetime
-
-
-class LogicalName(cdt.ReportMixin, cdt.OctetString, size=6):
-    """ Logical Name type. Default is CLock#1 """
-    __pattern = re.compile("(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})")
-    __match_args__ = ('a', 'b', 'c', 'd', 'e', 'f')
-    DEFAULT = b'\x00\x00\x01\x00\x00\xff'
-
-    @classmethod
-    def from_obis(cls, value: str) -> Self:
-        """ create logical_name: octet_string from string type ddd.ddd.ddd.ddd.ddd.ddd, ex.: 0.0.1.0.0.255 """
-        if (res := cls.__pattern.search(value)) is None:
-            raise ValueError(F"got wrong obis: {value}")
-        else:
-            return cls(bytearray(map(int, res.groups())))
-
-    def get_report(self) -> cdt.Report:
-        return cdt.Report('.'.join(map(str, self.contents)))  # todo: add error handle
-
-    def validate_from(self, value: str, cursor_position=None) -> tuple[str, int]:
-        try:
-            possible = type(self)(value)
-            return value, cursor_position  # TODO: wrong position ???
-        except ValueError:
-            with_separator = F'{value[:-1]}.{value[-1]}'
-            type(self)(with_separator)  # check possible
-            return with_separator, cursor_position
-
-    def __hash__(self) -> int:
-        return int.from_bytes(self.contents, 'big')
-
-    @property
-    def a(self) -> int:
-        """ group A """
-        return self.contents[0]
-
-    @property
-    def b(self) -> int:
-        """ group B """
-        return self.contents[1]
-
-    @property
-    def c(self) -> int:
-        """ group C """
-        return self.contents[2]
-
-    @property
-    def d(self) -> int:
-        """ group D """
-        return self.contents[3]
-
-    @property
-    def e(self) -> int:
-        """ group E """
-        return self.contents[4]
-
-    @property
-    def f(self) -> int:
-        """ group F """
-        return self.contents[5]
-
-    def __lt__(self, other: Self) -> bool:
-        return self.contents < other.contents
-
-
-class OctetStringDateTime(cdt.DateTime, tag=9, size=12):
-    """ type Time in OctetString(SIZE(12)) """
-
-    def __init__(self, value: bytes | bytearray | str | int | datetime.datetime | datetime.date | datetime.time = b'\x09\x0c\x07\xe4\x01\x01\xff\xff\xff\xff\xff\x80\x00\xff'):
-        match value:  # TODO: common for all OctetDateTimes
-            case bytes() if value[1] == len(self): super().__init__(self.TAG+value[2:])
-            case bytes():                          raise ValueError(F'in create {self.__class__.__name__} got tag, size: {cdt.TAG(value[0])} {value[1]}, expected {self.TAG} {len(self)}')
-            case _:                                super().__init__(value)
-
-    @property
-    def encoding(self) -> bytes:
-        return b'\x09\x0c' + self.contents
-
-
-class OctetStringDate(cdt.Date, tag=9, size=5):
-    """ type Time in OctetString(SIZE(5)) """
-
-    def __init__(self, value: bytes | bytearray | str | int | datetime.datetime | datetime.date = b'\x09\x05\x07\xe4\x01\x01\xff'):
-        match value:  # TODO: replace priority case
-            case bytes() if value[1] == len(self): super().__init__(self.TAG+value[2:])
-            case bytes():                          raise ValueError(F'in create {self.__class__.__name__} got tag, size: {cdt.TAG(value[0])} {value[1]}, expected {self.TAG} {len(self)}')
-            case _:                                super().__init__(value)
-
-    @property
-    def encoding(self) -> bytes:
-        return b'\x09\x05' + self.contents
-
-
-class OctetStringTime(cdt.Time, tag=9, size=4):
-    """ type Time in OctetString(SIZE(4)) """
-
-    def __init__(self, value: bytes | bytearray | str | int | datetime.datetime | datetime.time = b'\x09\x04\x00\x00\x00\x00'):
-        match value:  # TODO: replace priority case
-            case bytes() if value[1] == len(self): super().__init__(self.TAG+value[2:])
-            case bytes():                          raise ValueError(F'in create {self.__class__.__name__} got tag, size: {cdt.TAG(value[0])} {value[1]}, expected {self.TAG} {len(self)}')
-            case _:                                super().__init__(value)
-
-    @property
-    def encoding(self) -> bytes:
-        return b'\x09\x04' + self.contents
+from typing import Self
+import re
+from ..types import common_data_types as cdt
+import datetime
+
+
+class LogicalName(cdt.OctetString, cdt.ReportMixin, size=6):
+    """ Logical Name type. Default is CLock#1 """
+    __pattern = re.compile("(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})")
+    __match_args__ = ('a', 'b', 'c', 'd', 'e', 'f')
+    DEFAULT = b'\x00\x00\x01\x00\x00\xff'
+
+    @classmethod
+    def from_obis(cls, value: str) -> Self:
+        """ create logical_name: octet_string from string type ddd.ddd.ddd.ddd.ddd.ddd, ex.: 0.0.1.0.0.255 """
+        if (res := cls.__pattern.search(value)) is None:
+            raise ValueError(F"got wrong obis: {value}")
+        else:
+            return cls(bytearray(map(int, res.groups())))
+
+    def get_report(self) -> cdt.Report:
+        return cdt.Report('.'.join(map(str, self.contents)))  # todo: add error handle
+
+    def validate_from(self, value: str, cursor_position=None) -> tuple[str, int]:
+        try:
+            possible = type(self)(value)
+            return value, cursor_position  # TODO: wrong position ???
+        except ValueError:
+            with_separator = F'{value[:-1]}.{value[-1]}'
+            type(self)(with_separator)  # check possible
+            return with_separator, cursor_position
+
+    def __hash__(self) -> int:
+        return int.from_bytes(self.contents, 'big')
+
+    @property
+    def a(self) -> int:
+        """ group A """
+        return self.contents[0]
+
+    @property
+    def b(self) -> int:
+        """ group B """
+        return self.contents[1]
+
+    @property
+    def c(self) -> int:
+        """ group C """
+        return self.contents[2]
+
+    @property
+    def d(self) -> int:
+        """ group D """
+        return self.contents[3]
+
+    @property
+    def e(self) -> int:
+        """ group E """
+        return self.contents[4]
+
+    @property
+    def f(self) -> int:
+        """ group F """
+        return self.contents[5]
+
+    def __lt__(self, other: Self) -> bool:
+        return self.contents < other.contents
+
+
+class OctetStringDateTime(cdt.DateTime, tag=9, size=12):
+    """ type Time in OctetString(SIZE(12)) """
+
+    def __init__(self, value: bytes | bytearray | str | int | datetime.datetime | datetime.date | datetime.time = b'\x09\x0c\x07\xe4\x01\x01\xff\xff\xff\xff\xff\x80\x00\xff'):
+        match value:  # TODO: common for all OctetDateTimes
+            case bytes() if value[1] == len(self): super().__init__(self.TAG+value[2:])
+            case bytes():                          raise ValueError(F'in create {self.__class__.__name__} got tag, size: {cdt.TAG(value[0])} {value[1]}, expected {self.TAG} {len(self)}')
+            case _:                                super().__init__(value)
+
+    @property
+    def encoding(self) -> bytes:
+        return b'\x09\x0c' + self.contents
+
+
+class OctetStringDate(cdt.Date, tag=9, size=5):
+    """ type Time in OctetString(SIZE(5)) """
+
+    def __init__(self, value: bytes | bytearray | str | int | datetime.datetime | datetime.date = b'\x09\x05\x07\xe4\x01\x01\xff'):
+        match value:  # TODO: replace priority case
+            case bytes() if value[1] == len(self): super().__init__(self.TAG+value[2:])
+            case bytes():                          raise ValueError(F'in create {self.__class__.__name__} got tag, size: {cdt.TAG(value[0])} {value[1]}, expected {self.TAG} {len(self)}')
+            case _:                                super().__init__(value)
+
+    @property
+    def encoding(self) -> bytes:
+        return b'\x09\x05' + self.contents
+
+
+class OctetStringTime(cdt.Time, tag=9, size=4):
+    """ type Time in OctetString(SIZE(4)) """
+
+    def __init__(self, value: bytes | bytearray | str | int | datetime.datetime | datetime.time = b'\x09\x04\x00\x00\x00\x00'):
+        match value:  # TODO: replace priority case
+            case bytes() if value[1] == len(self): super().__init__(self.TAG+value[2:])
+            case bytes():                          raise ValueError(F'in create {self.__class__.__name__} got tag, size: {cdt.TAG(value[0])} {value[1]}, expected {self.TAG} {len(self)}')
+            case _:                                super().__init__(value)
+
+    @property
+    def encoding(self) -> bytes:
+        return b'\x09\x04' + self.contents

DLMS_SPODES/types/implementations/arrays.py

@@ -1,25 +1,25 @@
-from typing import Any
-from abc import ABC, abstractmethod
-from ...types import common_data_types as cdt
-from .structs import UserListEntry
-from .double_long_usingneds import IPAddress
-
-
-class SelectionAccess(cdt.Array):
-    """Use as buffer in ProfileGeneric and object_list in AssociationLN"""
-    selective_access: Any | None = None
-    TYPE: cdt.Structure
-
-    # @abstractmethod
-    # def is_writable(self, ln: cst.LogicalName, indexes: set[int]) -> bool:
-    #     """ index - DLMS object attribute index.
-    #      True: DLMS object with ln and index has writable Access"""
-
-
-class MulticastIPAddress(cdt.Array):
-    TYPE = IPAddress
-
-
-class UserList(cdt.Array):
-    """user_list. for AssociationLN(SN)"""
-    TYPE = UserListEntry
+from typing import Any
+from abc import ABC, abstractmethod
+from ...types import common_data_types as cdt
+from .structs import UserListEntry
+from .double_long_usingneds import IPAddress
+
+
+class SelectionAccess(cdt.Array):
+    """Use as buffer in ProfileGeneric and object_list in AssociationLN"""
+    selective_access: Any | None = None
+    TYPE: cdt.Structure
+
+    # @abstractmethod
+    # def is_writable(self, ln: cst.LogicalName, indexes: set[int]) -> bool:
+    #     """ index - DLMS object attribute index.
+    #      True: DLMS object with ln and index has writable Access"""
+
+
+class MulticastIPAddress(cdt.Array):
+    TYPE = IPAddress
+
+
+class UserList(cdt.Array):
+    """user_list. for AssociationLN(SN)"""
+    TYPE = UserListEntry

DLMS_SPODES/types/implementations/bitstrings.py

@@ -1,97 +1,97 @@
-from ...types import common_data_types as cdt
-from ...config_parser import get_values
-from ...settings import settings
-
-
-base = get_values("DLMS", "Conformance")
-
-
-# TODO: join with cdt.FlagMixin
-class Conformance(cdt.BitString):
-    ELEMENTS = ("reserved-zero",
-                "general-protection",
-                "general-block-transfer",
-                "read",
-                "write",
-                "unconfirmed-write",
-                "reserved-six",
-                "reserved-seven",
-                "attribute0-supported-with-set",
-                "priority-mgmt-supported",
-                "attribute0-supported-with-get",
-                "block-transfer-with-get-or-read",
-                "block-transfer-with-set-or-write",
-                "block-transfer-with-action",
-                "multiple-references",
-                "information-report",
-                "data-notification",
-                "access",
-                "parameterized-access",
-                "get",
-                "set",
-                "selective-access",
-                "event-notification",
-                "action")
-    if base is not None:
-        ELEMENTS = tuple(base[el] for el in ELEMENTS)
-    default = '011111111111111111111111'  # zero only 1 bit
-
-    def __init__(self, value: bytes | bytearray | str | int | cdt.BitString = None):
-        super(Conformance, self).__init__(value)
-        if self.ELEMENTS is not None and len(self) != len(self.ELEMENTS):
-            raise ValueError(F'For {self.__class__.__name__} get {len(self)} bits, expected {len(self.ELEMENTS)}')
-
-    def __len__(self):
-        return 24
-
-    def from_bytes(self, value: bytes) -> bytes:
-        length, pdu = cdt.get_length_and_pdu(value[1:])
-        if length != len(self):
-            raise ValueError(F'Got {length=}, expected {len(self)}')
-        match value[:1]:
-            case self.TAG if len(self) <= len(pdu) * 8: return pdu[:3]
-            case self.TAG:                              raise ValueError(F'Got pdu length:{len(pdu)}, expected at least {len(self) >> 3}')
-            case _ as error:                            raise TypeError(F'Expected {self.NAME} type, got {cdt.get_common_data_type_from(error).NAME}')
-
-    def from_str(self, value: str) -> bytes:
-        value = value + '0' * ((8 - len(self)) % 8)
-        list_ = [value[count:(count + 8)] for count in range(0, len(self), 8)]
-        value = b''
-        for byte in list_:
-            value += int(byte, base=2).to_bytes(1, byteorder='little')
-        return value
-
-    def from_int(self, value: int) -> bytes:
-        if value < 0:
-            raise ValueError
-        res = 0
-        start_bit = 2 ** (len(self) - 1)
-        for i in range(len(self)):
-            if value & (1 << i):
-                res += start_bit >> i
-        return res.to_bytes(len(self) // 8, byteorder='big')
-
-    def from_bytearray(self, value: bytearray) -> bytes:
-        return bytes(value)
-
-    @classmethod
-    def get_values(cls) -> list[str]:
-        """ TODO: """
-        return cls.ELEMENTS
-
-    def validate_from(self, value: str, cursor_position: int) -> tuple[str, int]:
-        """ return validated value and cursor position. TODO: copypast FlagMixin """
-        type(self)(value=value.zfill(len(self)))
-        return value, cursor_position
-
-    @property
-    def general_protection(self) -> int:
-        return tuple(self)[1]
-
-    @property
-    def general_block_transfer(self) -> int:
-        return tuple(self)[2]
-
-    @property
-    def selective_access(self) -> int:
-        return tuple(self)[21]
+from ...types import common_data_types as cdt
+from ...config_parser import get_values
+from ...settings import settings
+
+
+base = get_values("DLMS", "Conformance")
+
+
+# TODO: join with cdt.FlagMixin
+class Conformance(cdt.BitString):
+    ELEMENTS = ("reserved-zero",
+                "general-protection",
+                "general-block-transfer",
+                "read",
+                "write",
+                "unconfirmed-write",
+                "reserved-six",
+                "reserved-seven",
+                "attribute0-supported-with-set",
+                "priority-mgmt-supported",
+                "attribute0-supported-with-get",
+                "block-transfer-with-get-or-read",
+                "block-transfer-with-set-or-write",
+                "block-transfer-with-action",
+                "multiple-references",
+                "information-report",
+                "data-notification",
+                "access",
+                "parameterized-access",
+                "get",
+                "set",
+                "selective-access",
+                "event-notification",
+                "action")
+    if base is not None:
+        ELEMENTS = tuple(base[el] for el in ELEMENTS)
+    default = '011111111111111111111111'  # zero only 1 bit
+
+    def __init__(self, value: bytes | bytearray | str | int | cdt.BitString = None):
+        super(Conformance, self).__init__(value)
+        if self.ELEMENTS is not None and len(self) != len(self.ELEMENTS):
+            raise ValueError(F'For {self.__class__.__name__} get {len(self)} bits, expected {len(self.ELEMENTS)}')
+
+    def __len__(self):
+        return 24
+
+    def from_bytes(self, value: bytes) -> bytes:
+        length, pdu = cdt.get_length_and_pdu(value[1:])
+        if length != len(self):
+            raise ValueError(F'Got {length=}, expected {len(self)}')
+        match value[:1]:
+            case self.TAG if len(self) <= len(pdu) * 8: return pdu[:3]
+            case self.TAG:                              raise ValueError(F'Got pdu length:{len(pdu)}, expected at least {len(self) >> 3}')
+            case _ as error:                            raise TypeError(F'Expected {self.NAME} type, got {cdt.get_common_data_type_from(error).NAME}')
+
+    def from_str(self, value: str) -> bytes:
+        value = value + '0' * ((8 - len(self)) % 8)
+        list_ = [value[count:(count + 8)] for count in range(0, len(self), 8)]
+        value = b''
+        for byte in list_:
+            value += int(byte, base=2).to_bytes(1, byteorder='little')
+        return value
+
+    def from_int(self, value: int) -> bytes:
+        if value < 0:
+            raise ValueError
+        res = 0
+        start_bit = 2 ** (len(self) - 1)
+        for i in range(len(self)):
+            if value & (1 << i):
+                res += start_bit >> i
+        return res.to_bytes(len(self) // 8, byteorder='big')
+
+    def from_bytearray(self, value: bytearray) -> bytes:
+        return bytes(value)
+
+    @classmethod
+    def get_values(cls) -> list[str]:
+        """ TODO: """
+        return cls.ELEMENTS
+
+    def validate_from(self, value: str, cursor_position: int) -> tuple[str, int]:
+        """ return validated value and cursor position. TODO: copypast FlagMixin """
+        type(self)(value=value.zfill(len(self)))
+        return value, cursor_position
+
+    @property
+    def general_protection(self) -> int:
+        return tuple(self)[1]
+
+    @property
+    def general_block_transfer(self) -> int:
+        return tuple(self)[2]
+
+    @property
+    def selective_access(self) -> int:
+        return tuple(self)[21]

DLMS_SPODES/types/implementations/double_long_usingneds.py

@@ -1,35 +1,35 @@
-from ...types import common_data_types as cdt
-
-
-class DoubleLongUnsignedSecond(cdt.DoubleLongUnsigned):
-    """for second implementation"""
-
-
-class IPAddress(cdt.DoubleLongUnsigned):
-    """with string parser"""
-
-    def from_str(self, value: str) -> bytes:
-        """ create ip: integer from string type ddd.ddd.ddd.ddd, ex.: 127.0.0.1 """
-        raw_value = bytes()
-        for separator in '... ':
-            try:
-                element, value = value.split(separator, 1)
-            except ValueError:
-                element, value = value, ''
-            raw_value += self.__get_attr_element(element)
-        return raw_value
-
-    @staticmethod
-    def __get_attr_element(value: str) -> bytes:
-        if isinstance(value, str):
-            if value == '':
-                return b'\x00'
-            try:
-                return int(value).to_bytes(1, 'big')
-            except OverflowError:
-                raise ValueError(F'Int too big to convert {value}')
-        else:
-            raise TypeError(F'Unsupported type validation from string, got {value.__class__}')
-
-    def __str__(self):
-        return F'{self.contents[0]}.{self.contents[1]}.{self.contents[2]}.{self.contents[3]}'
+from ...types import common_data_types as cdt
+
+
+class DoubleLongUnsignedSecond(cdt.DoubleLongUnsigned):
+    """for second implementation"""
+
+
+class IPAddress(cdt.DoubleLongUnsigned):
+    """with string parser"""
+
+    def from_str(self, value: str) -> bytes:
+        """ create ip: integer from string type ddd.ddd.ddd.ddd, ex.: 127.0.0.1 """
+        raw_value = bytes()
+        for separator in '... ':
+            try:
+                element, value = value.split(separator, 1)
+            except ValueError:
+                element, value = value, ''
+            raw_value += self.__get_attr_element(element)
+        return raw_value
+
+    @staticmethod
+    def __get_attr_element(value: str) -> bytes:
+        if isinstance(value, str):
+            if value == '':
+                return b'\x00'
+            try:
+                return int(value).to_bytes(1, 'big')
+            except OverflowError:
+                raise ValueError(F'Int too big to convert {value}')
+        else:
+            raise TypeError(F'Unsupported type validation from string, got {value.__class__}')
+
+    def __str__(self):
+        return F'{self.contents[0]}.{self.contents[1]}.{self.contents[2]}.{self.contents[3]}'

DLMS_SPODES/types/implementations/enums.py

@@ -1,57 +1,57 @@
-from ...types import common_data_types as cdt
-
-
-class CommSpeed(cdt.Enum, elements=tuple(range(10))):
-    """ The communication speed supported by the corresponding port. This communication speed can be overridden if the HDLC mode of a devive is entered through a special mode
-    of another protocol. """
-
-    def to_transcript(self) -> int:
-        """ override enum key to enum value"""
-        match self.contents:
-            case b'\x00':  return 300
-            case b'\x01':  return 600
-            case b'\x02':  return 1200
-            case b'\x03':  return 2400
-            case b'\x04':  return 4800
-            case b'\x05':  return 9600
-            case b'\x06':  return 19200
-            case b'\x07':  return 38400
-            case b'\x08':  return 57600
-            case b'\x09':  return 115200
-            case _ as err: raise ValueError(F'Wrong CommSpeed: {err}, expected {CommSpeed.ELEMENTS.keys()}')
-
-    def from_int(self, value: int) -> bytes:
-        """ additional cases with Speed Values"""
-        match value:
-            case 300:    return b'\x00'
-            case 600:    return b'\x01'
-            case 1200:   return b'\x02'
-            case 2400:   return b'\x03'
-            case 4800:   return b'\x04'
-            case 9600:   return b'\x05'
-            case 19200:  return b'\x06'
-            case 38400:  return b'\x07'
-            case 57600:  return b'\x08'
-            case 115200: return b'\x09'
-            case other:  return super(CommSpeed, self).from_int(other)
-
-
-class RestrictionType(cdt.Enum, elements=(0, 1, 2)):
-    """"""
-
-
-class KeyInfoType(cdt.Enum, elements=(0, 1, 2)):
-    """"""
-
-
-
-class ProtectionType(cdt.Enum, elements=(0, 1, 2, 3)):
-    """"""
-
-
-class ClientSAP(cdt.Enum, elements=(0, 1, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60)):  # TODO: REWRITE elements here
-    """ IEC 62056-46 2002 6.4.2.3 Reserved special HDLC addresses p.40. IS15952ver2 """
-    TAG = b'\x0f'
-
-
-configurator_client = ClientSAP(0x30)
+from ...types import common_data_types as cdt
+
+
+class CommSpeed(cdt.Enum, elements=tuple(range(10))):
+    """ The communication speed supported by the corresponding port. This communication speed can be overridden if the HDLC mode of a devive is entered through a special mode
+    of another protocol. """
+
+    def to_transcript(self) -> int:
+        """ override enum key to enum value"""
+        match self.contents:
+            case b'\x00':  return 300
+            case b'\x01':  return 600
+            case b'\x02':  return 1200
+            case b'\x03':  return 2400
+            case b'\x04':  return 4800
+            case b'\x05':  return 9600
+            case b'\x06':  return 19200
+            case b'\x07':  return 38400
+            case b'\x08':  return 57600
+            case b'\x09':  return 115200
+            case _ as err: raise ValueError(F'Wrong CommSpeed: {err}, expected {CommSpeed.ELEMENTS.keys()}')
+
+    def from_int(self, value: int) -> bytes:
+        """ additional cases with Speed Values"""
+        match value:
+            case 300:    return b'\x00'
+            case 600:    return b'\x01'
+            case 1200:   return b'\x02'
+            case 2400:   return b'\x03'
+            case 4800:   return b'\x04'
+            case 9600:   return b'\x05'
+            case 19200:  return b'\x06'
+            case 38400:  return b'\x07'
+            case 57600:  return b'\x08'
+            case 115200: return b'\x09'
+            case other:  return super(CommSpeed, self).from_int(other)
+
+
+class RestrictionType(cdt.Enum, elements=(0, 1, 2)):
+    """"""
+
+
+class KeyInfoType(cdt.Enum, elements=(0, 1, 2)):
+    """"""
+
+
+
+class ProtectionType(cdt.Enum, elements=(0, 1, 2, 3)):
+    """"""
+
+
+class ClientSAP(cdt.Enum, elements=(0, 1, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60)):  # TODO: REWRITE elements here
+    """ IEC 62056-46 2002 6.4.2.3 Reserved special HDLC addresses p.40. IS15952ver2 """
+    TAG = b'\x0f'
+
+
+configurator_client = ClientSAP(0x30)