moved decryption logic and simplified it a bit

* added a bit of documentation on how to run tests

* formatting

* formatting

* formatting

* formatting

* formatting

* formatting

.github/workflows/tests.yml

@@ -17,18 +17,19 @@ jobs:
           - '3.9'
           - '3.10'
           - '3.11'
+          - '3.12'
 
     name: Python ${{ matrix.python-version }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
       - name: Cached PIP dependencies
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             ~/.cache/pip
@@ -43,4 +44,4 @@ jobs:
         run: tox
 
       - name: Code coverage upload
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4

.gitignore

@@ -3,6 +3,7 @@
 .tox
 .cache
 .venv
+.history
 *.egg-info
 /.project
 /.pydevproject

CHANGELOG.rst

@@ -1,19 +1,36 @@
 Change Log
 ----------
 
+**1.4.2** (2024-07-14)
+
+- Bump Github Actions to latest versions in favor of Node deprecations (`PR #159 <https://github.com/ndokter/dsmr_parser/pull/159>`_ by `dennissiemensma <https://github.com/dennissiemensma>`_)
+- Swap pyserial-asyncio for pyserial-asyncio-fast (`PR #158 <https://github.com/ndokter/dsmr_parser/pull/158>`_ by `bdraco <https://github.com/bdraco>`_)
+
+**1.4.1** (2024-06-04)
+
+- Avoid loading timezone at runtime (`PR #157 <https://github.com/ndokter/dsmr_parser/pull/157>`_ by `elupus <https://github.com/elupus>`_)
+
+**1.4.0** (2024-03-12)
+
+- Mbus alt (`PR #142 <https://github.com/ndokter/dsmr_parser/pull/142>`_ by `dupondje <https://github.com/dupondje>`_)
+- Q3D add CURRENT_ELECTRICITY_DELIVERY (`PR #149 <https://github.com/ndokter/dsmr_parser/pull/149>`_ by `Aeroid <https://github.com/Aeroid>`_)
+- Copy head_parsers list on construct. (`PR #150 <https://github.com/ndokter/dsmr_parser/pull/150>`_ by `dupondje <https://github.com/dupondje>`_)
+
+**1.3.2** (2024-01-29)
+
+- Fix unit test for pyton 3.12 (`PR #148 <https://github.com/ndokter/dsmr_parser/pull/148>`_ by `ndokter <https://github.com/ndokter>`_)
+
 **1.3.1** (2023-11-06)
-- Fix parsing peak usage with invalid timestamps
- (`PR #143 <https://github.com/ndokter/dsmr_parser/pull/143>`_ by `dupondje <https://github.com/dupondje>`_)
+
+- Fix parsing peak usage with invalid timestamps (`PR #143 <https://github.com/ndokter/dsmr_parser/pull/143>`_ by `dupondje <https://github.com/dupondje>`_)
 
 **1.3.0** (2023-08-01)
 
-- added E.ON Hungary; refactored DSMR specifications to fix obis reference conflicts
- (`PR #137 <https://github.com/ndokter/dsmr_parser/pull/137>`_ by `balazs92117 <https://github.com/balazs92117>`_)
+- added E.ON Hungary; refactored DSMR specifications to fix obis reference conflicts (`PR #137 <https://github.com/ndokter/dsmr_parser/pull/137>`_ by `balazs92117 <https://github.com/balazs92117>`_)
 
 **1.2.4** (2023-07-11)
 
-- EQUIPMENT IDENTIFIER is wrong for Fluvius meters when other mbus devices are present
- (`PR #133 <https://github.com/ndokter/dsmr_parser/pull/133>`_ by `ejpalacios <https://github.com/ejpalacios>`_)
+- EQUIPMENT IDENTIFIER is wrong for Fluvius meters when other mbus devices are present (`PR #133 <https://github.com/ndokter/dsmr_parser/pull/133>`_ by `ejpalacios <https://github.com/ejpalacios>`_)
 
 
 **1.2.3** (2023-04-18)

README.rst

@@ -293,6 +293,36 @@ To install DSMR Parser:
 
     $ pip install dsmr-parser
 
+Development
+-----------
+
+Create a virtualenv and activate it followed by the installation of the dsmr-parser:
+
+.. code-block:: bash
+
+    python3 -m venv venv
+    source venv/bin/activate
+    pip install -e .
+
+Install tox and run it:
+
+.. code-block:: bash
+
+    pip install tox
+    tox
+
+You should see that the tests have succeeded:
+
+.. code-block:: text
+
+    ======================================================================================================== 59 passed in 0.91s ========================================================================================================
+    py: commands[1]> pylama dsmr_parser test
+      py: OK (11.55=setup[9.73]+cmd[1.29,0.53] seconds)
+      congratulations :) (11.69 seconds)
+
+
+Now you can make changes by editing the code and rerunning tox to verify your changes.
+
 Known issues
 ------------
 

dsmr_parser/clients/filereader.py

@@ -73,7 +73,7 @@ class FileReader(object):
                     try:
                         yield self.telegram_parser.parse(telegram)
                     except InvalidChecksumError as e:
-                        logger.warning(str(e))
+                        logger.info(str(e))
                     except ParseError as e:
                         logger.error('Failed to parse telegram: %s', e)
 

dsmr_parser/clients/protocol.py

@@ -4,7 +4,7 @@ from functools import partial
 import asyncio
 import logging
 
-from serial_asyncio import create_serial_connection
+from serial_asyncio_fast import create_serial_connection
 
 from dsmr_parser import telegram_specifications
 from dsmr_parser.clients.telegram_buffer import TelegramBuffer
@@ -158,7 +158,7 @@ class DSMRProtocol(asyncio.Protocol):
         try:
             parsed_telegram = self.telegram_parser.parse(telegram)
         except InvalidChecksumError as e:
-            self.log.warning(str(e))
+            self.log.info(str(e))
         except ParseError:
             self.log.exception("failed to parse telegram")
         else:

dsmr_parser/clients/rfxtrx_protocol.py

@@ -2,7 +2,7 @@
 
 import asyncio
 
-from serial_asyncio import create_serial_connection
+from serial_asyncio_fast import create_serial_connection
 from .protocol import DSMRProtocol, _create_dsmr_protocol
 
 

dsmr_parser/clients/serial_.py

@@ -1,6 +1,6 @@
 import logging
 import serial
-import serial_asyncio
+import serial_asyncio_fast
 
 from dsmr_parser.clients.telegram_buffer import TelegramBuffer
 from dsmr_parser.exceptions import ParseError, InvalidChecksumError
@@ -37,7 +37,7 @@ class SerialReader(object):
                     try:
                         yield self.telegram_parser.parse(telegram)
                     except InvalidChecksumError as e:
-                        logger.warning(str(e))
+                        logger.info(str(e))
                     except ParseError as e:
                         logger.error('Failed to parse telegram: %s', e)
 
@@ -77,7 +77,7 @@ class AsyncSerialReader(SerialReader):
         :rtype: None
         """
         # create Serial StreamReader
-        conn = serial_asyncio.open_serial_connection(**self.serial_settings)
+        conn = serial_asyncio_fast.open_serial_connection(**self.serial_settings)
         reader, _ = await conn
 
         while True:
@@ -107,7 +107,7 @@ class AsyncSerialReader(SerialReader):
         """
 
         # create Serial StreamReader
-        conn = serial_asyncio.open_serial_connection(**self.serial_settings)
+        conn = serial_asyncio_fast.open_serial_connection(**self.serial_settings)
         reader, _ = await conn
 
         while True:

dsmr_parser/clients/socket_.py

@@ -31,11 +31,15 @@ class SocketReader(object):
         buffer = b""
 
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as socket_handle:
-
+            socket_handle.settimeout(60)
             socket_handle.connect((self.host, self.port))
 
             while True:
-                buffer += socket_handle.recv(self.BUFFER_SIZE)
+                try:
+                    buffer += socket_handle.recv(self.BUFFER_SIZE)
+                except socket.timeout:
+                    logger.error("Socket timeout occurred, exiting")
+                    break
 
                 lines = buffer.splitlines(keepends=True)
 
@@ -54,7 +58,7 @@ class SocketReader(object):
                     try:
                         yield self.telegram_parser.parse(telegram)
                     except InvalidChecksumError as e:
-                        logger.warning(str(e))
+                        logger.info(str(e))
                     except ParseError as e:
                         logger.error('Failed to parse telegram: %s', e)
 

dsmr_parser/obis_references.py

@@ -43,6 +43,9 @@ INSTANTANEOUS_VOLTAGE_L3 = r'^\d-\d:72\.7\.0.+?\r\n'
 INSTANTANEOUS_CURRENT_L1 = r'^\d-\d:31\.7\.0.+?\r\n'
 INSTANTANEOUS_CURRENT_L2 = r'^\d-\d:51\.7\.0.+?\r\n'
 INSTANTANEOUS_CURRENT_L3 = r'^\d-\d:71\.7\.0.+?\r\n'
+FUSE_THRESHOLD_L1 = r'^\d-\d:31\.4\.0.+?\r\n'  # Applicable when current limitation is active
+FUSE_THRESHOLD_L2 = r'^\d-\d:51\.4\.0.+?\r\n'  # Applicable when current limitation is active
+FUSE_THRESHOLD_L3 = r'^\d-\d:71\.4\.0.+?\r\n'  # Applicable when current limitation is active
 TEXT_MESSAGE_CODE = r'^\d-\d:96\.13\.1.+?\r\n'
 TEXT_MESSAGE = r'^\d-\d:96\.13\.0.+?\r\n'
 DEVICE_TYPE = r'^\d-\d:24\.1\.0.+?\r\n'
@@ -66,8 +69,25 @@ ACTUAL_TRESHOLD_ELECTRICITY = r'^\d-\d:17\.0\.0.+?\r\n'
 ACTUAL_SWITCH_POSITION = r'^\d-\d:96\.3\.10.+?\r\n'
 VALVE_POSITION_GAS = r'^\d-\d:24\.4\.0.+?\r\n'
 
+# Multiple 'slaves' can be linked to the main device.
+# The type is reported on 24.1.0
+# Specifications are in EN 13757-3
+# For example: Water mater = 7, Gas meter = 3
+# Identifier is on 96.1.0 (in NL for ex) or
+# on 96.1.1 (in BE for ex)
+# The values are reported on 24.2.1
+# With an exception in Belgium for the GAS meter
+# Be aware that for the gas volume, another OBIS-code is published
+# than the one listed in section 7 of DSMR P1.
+# This is due to the fact that in Belgium the not-temperature
+# corrected gas volume is used while in the Netherlands,
+# the temperature corrected gas volume is used.
+MBUS_DEVICE_TYPE = r'^\d-[1-9]:24\.1\.0.+?\r\n'
+MBUS_EQUIPMENT_IDENTIFIER = r'^\d-[1-9]:96\.1\.[01].+?\r\n'
+MBUS_VALVE_POSITION = r'^\d-[1-9]:24\.4\.0.+?\r\n'
+MBUS_METER_READING = r'^\d-[1-9]:24\.2\.[13].+?\r\n'
+
 # TODO 17.0.0
-# TODO 96.3.10
 
 ELECTRICITY_USED_TARIFF_ALL = (
     ELECTRICITY_USED_TARIFF_1,
@@ -88,38 +108,6 @@ BELGIUM_EQUIPMENT_IDENTIFIER = r'^\d-0:96\.1\.1.+?\r\n'
 BELGIUM_CURRENT_AVERAGE_DEMAND = r'^\d-\d:1\.4\.0.+?\r\n'
 BELGIUM_MAXIMUM_DEMAND_MONTH = r'^\d-\d:1\.6\.0.+?\r\n'
 BELGIUM_MAXIMUM_DEMAND_13_MONTHS = r'^\d-\d:98\.1\.0.+?\r\n'
-BELGIUM_MAX_POWER_PER_PHASE = r'^\d-\d:17\.0\.0.+?\r\n'  # Applicable when power limitation is active
-BELGIUM_MAX_CURRENT_PER_PHASE = r'^\d-\d:31\.4\.0.+?\r\n'  # Applicable when current limitation is active
-
-# Multiple 'slaves' can be linked to the main device.
-# Mostly MBUS1 = GAS METER with values on 24.2.3
-# While WATER METER reports it's values on 24.2.1
-# The GAS METER also reports its valve state on 24.4.0
-# Dev type for gas = 7 and water = 8
-BELGIUM_MBUS1_DEVICE_TYPE = r'^\d-1:24\.1\.0.+?\r\n'
-BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER = r'^\d-1:96\.1\.1.+?\r\n'
-BELGIUM_MBUS1_VALVE_POSITION = r'^\d-1:24\.4\.0.+?\r\n'
-BELGIUM_MBUS1_METER_READING1 = r'^\d-1:24\.2\.1.+?\r\n'
-BELGIUM_MBUS1_METER_READING2 = r'^\d-1:24\.2\.3.+?\r\n'
-
-BELGIUM_MBUS2_DEVICE_TYPE = r'^\d-2:24\.1\.0.+?\r\n'
-BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER = r'^\d-2:96\.1\.1.+?\r\n'
-BELGIUM_MBUS2_VALVE_POSITION = r'^\d-2:24\.4\.0.+?\r\n'
-BELGIUM_MBUS2_METER_READING1 = r'^\d-2:24\.2\.1.+?\r\n'
-BELGIUM_MBUS2_METER_READING2 = r'^\d-2:24\.2\.3.+?\r\n'
-
-BELGIUM_MBUS3_DEVICE_TYPE = r'^\d-3:24\.1\.0.+?\r\n'
-BELGIUM_MBUS3_EQUIPMENT_IDENTIFIER = r'^\d-3:96\.1\.1.+?\r\n'
-BELGIUM_MBUS3_VALVE_POSITION = r'^\d-3:24\.4\.0.+?\r\n'
-BELGIUM_MBUS3_METER_READING1 = r'^\d-3:24\.2\.1.+?\r\n'
-BELGIUM_MBUS3_METER_READING2 = r'^\d-3:24\.2\.3.+?\r\n'
-
-BELGIUM_MBUS4_DEVICE_TYPE = r'^\d-4:24\.1\.0.+?\r\n'
-BELGIUM_MBUS4_EQUIPMENT_IDENTIFIER = r'^\d-4:96\.1\.1.+?\r\n'
-BELGIUM_MBUS4_VALVE_POSITION = r'^\d-4:24\.4\.0.+?\r\n'
-BELGIUM_MBUS4_METER_READING1 = r'^\d-4:24\.2\.1.+?\r\n'
-BELGIUM_MBUS4_METER_READING2 = r'^\d-4:24\.2\.3.+?\r\n'
-
 
 LUXEMBOURG_EQUIPMENT_IDENTIFIER = r'^\d-\d:42\.0\.0.+?\r\n'  # Logical device name
 
@@ -142,5 +130,3 @@ EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q1 = r'^\d-\d:5\.7\.0.+?\r\n'
 EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q2 = r'^\d-\d:6\.7\.0.+?\r\n'
 EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q3 = r'^\d-\d:7\.7\.0.+?\r\n'
 EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q4 = r'^\d-\d:8\.7\.0.+?\r\n'
-EON_HU_MAX_POWER_ON_L2 = r'^\d-\d:51\.4\.0.+?\r\n'
-EON_HU_MAX_POWER_ON_L3 = r'^\d-\d:71\.4\.0.+?\r\n'

dsmr_parser/objects.py

@@ -28,12 +28,12 @@ class Telegram(dict):
     def add(self, obis_reference, dsmr_object, obis_name):
         # Update name mapping used to get value by attribute. Example: telegram.P1_MESSAGE_HEADER
         setattr(self, obis_name, dsmr_object)
-        if obis_name not in self._item_names:  # TODO repeating obis references
-            self._item_names.append(obis_name)
 
         # TODO isinstance check: MaxDemandParser (BELGIUM_MAXIMUM_DEMAND_13_MONTHS) returns a list
         if isinstance(dsmr_object, DSMRObject) and dsmr_object.is_mbus_reading:
             self._add_mbus(obis_reference, dsmr_object, obis_name)
+        elif obis_name not in self._item_names:  # TODO repeating obis references
+            self._item_names.append(obis_name)
 
         # Fill dict which is only used for backwards compatibility
         if obis_reference not in self:

dsmr_parser/parsers.py

@@ -32,6 +32,7 @@ class TelegramParser(object):
             object["obis_reference"]: re.compile(object["obis_reference"], re.DOTALL | re.MULTILINE)
             for object in self.telegram_specification['objects']
         }
+        self._telegram_encryption_active = None
 
     def parse(self, telegram_data, encryption_key="", authentication_key="", throw_ex=False):  # noqa: C901
         """
@@ -46,38 +47,11 @@ class TelegramParser(object):
         :raises ParseError:
         :raises InvalidChecksumError:
         """
-
-        if "general_global_cipher" in self.telegram_specification:
-            if self.telegram_specification["general_global_cipher"]:
-                enc_key = unhexlify(encryption_key)
-                auth_key = unhexlify(authentication_key)
-                telegram_data = unhexlify(telegram_data)
-                apdu = XDlmsApduFactory.apdu_from_bytes(apdu_bytes=telegram_data)
-                if apdu.security_control.security_suite != 0:
-                    logger.warning("Untested security suite")
-                if apdu.security_control.authenticated and not apdu.security_control.encrypted:
-                    logger.warning("Untested authentication only")
-                if not apdu.security_control.authenticated and not apdu.security_control.encrypted:
-                    logger.warning("Untested not encrypted or authenticated")
-                if apdu.security_control.compressed:
-                    logger.warning("Untested compression")
-                if apdu.security_control.broadcast_key:
-                    logger.warning("Untested broadcast key")
-                telegram_data = apdu.to_plain_apdu(enc_key, auth_key).decode("ascii")
-            else:
-                try:
-                    if unhexlify(telegram_data[0:2])[0] == GeneralGlobalCipher.TAG:
-                        raise RuntimeError("Looks like a general_global_cipher frame "
-                                           "but telegram specification is not matching!")
-                except Exception:
-                    pass
-        else:
-            try:
-                if unhexlify(telegram_data[0:2])[0] == GeneralGlobalCipher.TAG:
-                    raise RuntimeError(
-                        "Looks like a general_global_cipher frame but telegram specification is not matching!")
-            except Exception:
-                pass
+        telegram_data = self.decrypt_telegram_data(
+            telegram_data=telegram_data,
+            encryption_key=encryption_key,
+            authentication_key=authentication_key
+        )
 
         if self.apply_checksum_validation and self.telegram_specification['checksum_support']:
             self.validate_checksum(telegram_data)
@@ -112,6 +86,42 @@ class TelegramParser(object):
 
         return telegram
 
+    def decrypt_telegram_data(self, encryption_key, authentication_key, telegram_data):
+        """
+        Check if telegram data is encrypted and decrypt if applicable.
+        """
+        # if self._telegram_encryption_active is False:
+        #     # If encryption is not working, stop trying and logging warnings.
+        #     return telegram_data
+
+        if self.telegram_specification.get("general_global_cipher"):
+            enc_key = unhexlify(encryption_key)
+            auth_key = unhexlify(authentication_key)
+            telegram_data = unhexlify(telegram_data)
+            apdu = XDlmsApduFactory.apdu_from_bytes(apdu_bytes=telegram_data)
+            if apdu.security_control.security_suite != 0:
+                logger.warning("Untested security suite")
+            if apdu.security_control.authenticated and not apdu.security_control.encrypted:
+                logger.warning("Untested authentication only")
+            if not apdu.security_control.authenticated and not apdu.security_control.encrypted:
+                logger.warning("Untested not encrypted or authenticated")
+            if apdu.security_control.compressed:
+                logger.warning("Untested compression")
+            if apdu.security_control.broadcast_key:
+                logger.warning("Untested broadcast key")
+            telegram_data = apdu.to_plain_apdu(enc_key, auth_key).decode("ascii")
+            self._telegram_encryption_active = True
+        else:
+            try:
+                if unhexlify(telegram_data[0:2])[0] == GeneralGlobalCipher.TAG:
+                    logger.warning("Looks like a general_global_cipher frame "
+                                   "but telegram specification is not matching!")
+            except Exception:
+                pass
+            self._telegram_encryption_active = False
+
+        return telegram_data
+
     @staticmethod
     def validate_checksum(telegram):
         """
@@ -335,7 +345,7 @@ class ProfileGenericParser(DSMRObjectParser):
     """
 
     def __init__(self, buffer_types, head_parsers, parsers_for_unidentified):
-        self.value_formats = head_parsers
+        self.value_formats = head_parsers.copy()
         self.buffer_types = buffer_types
         self.parsers_for_unidentified = parsers_for_unidentified
 

dsmr_parser/telegram_specifications.py

@@ -430,11 +430,6 @@ V5 = {
             'value_parser': CosemParser(ValueParser(str)),
             'value_name': 'TEXT_MESSAGE'
         },
-        {
-            'obis_reference': obis.DEVICE_TYPE,
-            'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'DEVICE_TYPE'
-        },
         {
             'obis_reference': obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE,
             'value_parser': CosemParser(ValueParser(Decimal)),
@@ -466,17 +461,27 @@ V5 = {
             'value_name': 'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE'
         },
         {
-            'obis_reference': obis.EQUIPMENT_IDENTIFIER_GAS,
-            'value_parser': CosemParser(ValueParser(str)),
-            'value_name': 'EQUIPMENT_IDENTIFIER_GAS'
+            'obis_reference': obis.MBUS_DEVICE_TYPE,
+            'value_parser': CosemParser(ValueParser(int)),
+            'value_name': 'MBUS_DEVICE_TYPE'
         },
         {
-            'obis_reference': obis.HOURLY_GAS_METER_READING,
-            'value_parser':  MBusParser(
+            'obis_reference': obis.MBUS_EQUIPMENT_IDENTIFIER,
+            'value_parser': CosemParser(ValueParser(str)),
+            'value_name': 'MBUS_EQUIPMENT_IDENTIFIER'
+        },
+        {
+            'obis_reference': obis.MBUS_VALVE_POSITION,
+            'value_parser': CosemParser(ValueParser(int)),
+            'value_name': 'MBUS_VALVE_POSITION'
+        },
+        {
+            'obis_reference': obis.MBUS_METER_READING,
+            'value_parser': MBusParser(
                 ValueParser(timestamp),
                 ValueParser(Decimal)
             ),
-            'value_name': 'HOURLY_GAS_METER_READING'
+            'value_name': 'MBUS_METER_READING'
         },
     ]
 }
@@ -625,14 +630,9 @@ BELGIUM_FLUVIUS = {
             'value_name': 'ACTUAL_TRESHOLD_ELECTRICITY'
         },
         {
-            'obis_reference': obis.BELGIUM_MAX_POWER_PER_PHASE,
+            'obis_reference': obis.FUSE_THRESHOLD_L1,
             'value_parser': CosemParser(ValueParser(Decimal)),
-            'value_name': 'BELGIUM_MAX_POWER_PER_PHASE'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MAX_CURRENT_PER_PHASE,
-            'value_parser': CosemParser(ValueParser(Decimal)),
-            'value_name': 'BELGIUM_MAX_CURRENT_PER_PHASE'
+            'value_name': 'FUSE_THRESHOLD_L1'
         },
         {
             'obis_reference': obis.TEXT_MESSAGE,
@@ -640,128 +640,27 @@ BELGIUM_FLUVIUS = {
             'value_name': 'TEXT_MESSAGE'
         },
         {
-            'obis_reference': obis.BELGIUM_MBUS1_DEVICE_TYPE,
+            'obis_reference': obis.MBUS_DEVICE_TYPE,
             'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'BELGIUM_MBUS1_DEVICE_TYPE'
+            'value_name': 'MBUS_DEVICE_TYPE'
         },
         {
-            'obis_reference': obis.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER,
+            'obis_reference': obis.MBUS_EQUIPMENT_IDENTIFIER,
             'value_parser': CosemParser(ValueParser(str)),
-            'value_name': 'BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER'
+            'value_name': 'MBUS_EQUIPMENT_IDENTIFIER'
         },
         {
-            'obis_reference': obis.BELGIUM_MBUS1_VALVE_POSITION,
+            'obis_reference': obis.MBUS_VALVE_POSITION,
             'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'BELGIUM_MBUS1_VALVE_POSITION'
+            'value_name': 'MBUS_VALVE_POSITION'
         },
         {
-            'obis_reference': obis.BELGIUM_MBUS1_METER_READING1,
+            'obis_reference': obis.MBUS_METER_READING,
             'value_parser': MBusParser(
                 ValueParser(timestamp),
                 ValueParser(Decimal)
             ),
-            'value_name': 'BELGIUM_MBUS1_METER_READING1'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS1_METER_READING2,
-            'value_parser': MBusParser(
-                ValueParser(timestamp),
-                ValueParser(Decimal)
-            ),
-            'value_name': 'BELGIUM_MBUS1_METER_READING2'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS2_DEVICE_TYPE,
-            'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'BELGIUM_MBUS2_DEVICE_TYPE'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER,
-            'value_parser': CosemParser(ValueParser(str)),
-            'value_name': 'BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS2_VALVE_POSITION,
-            'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'BELGIUM_MBUS2_VALVE_POSITION'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS2_METER_READING1,
-            'value_parser': MBusParser(
-                ValueParser(timestamp),
-                ValueParser(Decimal)
-            ),
-            'value_name': 'BELGIUM_MBUS2_METER_READING1'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS2_METER_READING2,
-            'value_parser': MBusParser(
-                ValueParser(timestamp),
-                ValueParser(Decimal)
-            ),
-            'value_name': 'BELGIUM_MBUS2_METER_READING2'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS3_DEVICE_TYPE,
-            'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'BELGIUM_MBUS3_DEVICE_TYPE'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS3_EQUIPMENT_IDENTIFIER,
-            'value_parser': CosemParser(ValueParser(str)),
-            'value_name': 'BELGIUM_MBUS3_EQUIPMENT_IDENTIFIER'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS3_VALVE_POSITION,
-            'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'BELGIUM_MBUS3_VALVE_POSITION'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS3_METER_READING1,
-            'value_parser': MBusParser(
-                ValueParser(timestamp),
-                ValueParser(Decimal)
-            ),
-            'value_name': 'BELGIUM_MBUS3_METER_READING1'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS3_METER_READING2,
-            'value_parser': MBusParser(
-                ValueParser(timestamp),
-                ValueParser(Decimal)
-            ),
-            'value_name': 'BELGIUM_MBUS3_METER_READING2'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS4_DEVICE_TYPE,
-            'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'BELGIUM_MBUS4_DEVICE_TYPE'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS4_EQUIPMENT_IDENTIFIER,
-            'value_parser': CosemParser(ValueParser(str)),
-            'value_name': 'BELGIUM_MBUS4_EQUIPMENT_IDENTIFIER'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS4_VALVE_POSITION,
-            'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'BELGIUM_MBUS4_VALVE_POSITION'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS4_METER_READING1,
-            'value_parser': MBusParser(
-                ValueParser(timestamp),
-                ValueParser(Decimal)
-            ),
-            'value_name': 'BELGIUM_MBUS4_METER_READING1'
-        },
-        {
-            'obis_reference': obis.BELGIUM_MBUS4_METER_READING2,
-            'value_parser': MBusParser(
-                ValueParser(timestamp),
-                ValueParser(Decimal)
-            ),
-            'value_name': 'BELGIUM_MBUS4_METER_READING2'
+            'value_name': 'MBUS_METER_READING'
         },
     ]
 }
@@ -962,6 +861,11 @@ Q3D = {
             'value_parser': CosemParser(ValueParser(Decimal)),
             'value_name': 'CURRENT_ELECTRICITY_USAGE'
         },
+        {
+            'obis_reference': obis.CURRENT_ELECTRICITY_DELIVERY,
+            'value_parser': CosemParser(ValueParser(Decimal)),
+            'value_name': 'CURRENT_ELECTRICITY_DELIVERY'
+        },
         {
             'obis_reference': obis.Q3D_EQUIPMENT_STATE,
             'value_parser': CosemParser(ValueParser(str)),
@@ -1233,7 +1137,7 @@ EON_HUNGARY = {
             # This seems to be wrong in documentation, it's not 0-0:96.50.68, but 0-0:96.3.10
         },
         {
-            'obis_reference': obis.BELGIUM_MAX_POWER_PER_PHASE,
+            'obis_reference': obis.ACTUAL_TRESHOLD_ELECTRICITY,
             'value_parser': CosemParser(ValueParser(Decimal)),
             'value_name': 'ACTUAL_TRESHOLD_ELECTRICITY'
         },
@@ -1414,20 +1318,20 @@ EON_HUNGARY = {
             'value_name': 'INSTANTANEOUS_REACTIVE_POWER_Q4'
         },
         {
-            'obis_reference': obis.BELGIUM_MAX_CURRENT_PER_PHASE,
+            'obis_reference': obis.FUSE_THRESHOLD_L1,
             'value_parser': CosemParser(ValueParser(Decimal)),
-            'value_name': 'MAX_POWER_ON_L1'
+            'value_name': 'FUSE_THRESHOLD_L1'
         },
         {
-            'obis_reference': obis.EON_HU_MAX_POWER_ON_L2,
+            'obis_reference': obis.FUSE_THRESHOLD_L2,
             'value_parser': CosemParser(ValueParser(Decimal)),
-            'value_name': 'MAX_POWER_ON_L2'
+            'value_name': 'FUSE_THRESHOLD_L2'
             # Only with 3 phase meters
         },
         {
-            'obis_reference': obis.EON_HU_MAX_POWER_ON_L3,
+            'obis_reference': obis.FUSE_THRESHOLD_L3,
             'value_parser': CosemParser(ValueParser(Decimal)),
-            'value_name': 'MAX_POWER_ON_L3'
+            'value_name': 'FUSE_THRESHOLD_L3'
             # Only with 3 phase meters
         },
         # I'm not sure which datas does this line containes. It should be the data of last minute of last month.

dsmr_parser/value_types.py

@@ -2,6 +2,10 @@ import datetime
 
 import pytz
 
+# TODO : Use system timezone
+# Preload timezone to avoid loading in event loop later
+local_tz = pytz.timezone('Europe/Amsterdam')
+
 
 def timestamp(value):
     try:
@@ -20,8 +24,6 @@ def timestamp(value):
     else:
         is_dst = False
 
-    # TODO : Use system timezone
-    local_tz = pytz.timezone('Europe/Amsterdam')
     localized_datetime = local_tz.localize(naive_datetime, is_dst=is_dst)
 
     return localized_datetime.astimezone(pytz.utc)

setup.py

@@ -7,11 +7,11 @@ setup(
     author_email='mail@nldr.net',
     license='MIT',
     url='https://github.com/ndokter/dsmr_parser',
-    version='1.3.1',
+    version='1.4.2',
     packages=find_packages(exclude=('test', 'test.*')),
     install_requires=[
         'pyserial>=3,<4',
-        'pyserial-asyncio<1',
+        'pyserial-asyncio-fast>=0.11',
         'pytz',
         'Tailer==0.4.1',
         'dlms_cosem==21.3.2'

test/clients/test_filereader.py

@@ -0,0 +1,21 @@
+import unittest
+import tempfile
+
+from dsmr_parser.clients.filereader import FileReader
+from dsmr_parser.telegram_specifications import V5
+from test.example_telegrams import TELEGRAM_V5
+
+
+class FileReaderTest(unittest.TestCase):
+    def test_read_as_object(self):
+        with tempfile.NamedTemporaryFile() as file:
+            with open(file.name, "w") as f:
+                f.write(TELEGRAM_V5)
+
+            telegrams = []
+            reader = FileReader(file=file.name, telegram_specification=V5)
+            # Call
+            for telegram in reader.read_as_object():
+                telegrams.append(telegram)
+
+            self.assertEqual(len(telegrams), 1)

test/clients/test_rfxtrx_protocol.py

@@ -0,0 +1,77 @@
+from unittest.mock import Mock
+
+import unittest
+
+from dsmr_parser import obis_references as obis
+from dsmr_parser.clients.rfxtrx_protocol import create_rfxtrx_dsmr_protocol, PACKETTYPE_DSMR, SUBTYPE_P1
+from dsmr_parser.objects import Telegram
+
+TELEGRAM_V2_2 = (
+    '/ISk5\2MT382-1004\r\n'
+    '\r\n'
+    '0-0:96.1.1(00000000000000)\r\n'
+    '1-0:1.8.1(00001.001*kWh)\r\n'
+    '1-0:1.8.2(00001.001*kWh)\r\n'
+    '1-0:2.8.1(00001.001*kWh)\r\n'
+    '1-0:2.8.2(00001.001*kWh)\r\n'
+    '0-0:96.14.0(0001)\r\n'
+    '1-0:1.7.0(0001.01*kW)\r\n'
+    '1-0:2.7.0(0000.00*kW)\r\n'
+    '0-0:17.0.0(0999.00*kW)\r\n'
+    '0-0:96.3.10(1)\r\n'
+    '0-0:96.13.1()\r\n'
+    '0-0:96.13.0()\r\n'
+    '0-1:24.1.0(3)\r\n'
+    '0-1:96.1.0(000000000000)\r\n'
+    '0-1:24.3.0(161107190000)(00)(60)(1)(0-1:24.2.1)(m3)\r\n'
+    '(00001.001)\r\n'
+    '0-1:24.4.0(1)\r\n'
+    '!\r\n'
+)
+
+OTHER_RF_PACKET = b'\x03\x01\x02\x03'
+
+
+def encode_telegram_as_RF_packets(telegram):
+    data = b''
+
+    for line in telegram.split('\n'):
+        packet_data = (line + '\n').encode('ascii')
+        packet_header = bytes(bytearray([
+            len(packet_data) + 3,  # excluding length byte
+            PACKETTYPE_DSMR,
+            SUBTYPE_P1,
+            0  # seq num (ignored)
+        ]))
+
+        data += packet_header + packet_data
+        # other RF packets can pass by on the line
+        data += OTHER_RF_PACKET
+
+    return data
+
+
+class RFXtrxProtocolTest(unittest.TestCase):
+
+    def setUp(self):
+        new_protocol, _ = create_rfxtrx_dsmr_protocol('2.2',
+                                                      telegram_callback=Mock(),
+                                                      keep_alive_interval=1)
+        self.protocol = new_protocol()
+
+    def test_complete_packet(self):
+        """Protocol should assemble incoming lines into complete packet."""
+
+        data = encode_telegram_as_RF_packets(TELEGRAM_V2_2)
+        # send data broken up in two parts
+        self.protocol.data_received(data[0:200])
+        self.protocol.data_received(data[200:])
+
+        telegram = self.protocol.telegram_callback.call_args_list[0][0][0]
+        assert isinstance(telegram, Telegram)
+
+        assert float(telegram[obis.CURRENT_ELECTRICITY_USAGE].value) == 1.01
+        assert telegram[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
+
+        assert float(telegram[obis.GAS_METER_READING].value) == 1.001
+        assert telegram[obis.GAS_METER_READING].unit == 'm3'

test/objects/test_mbusdevice.py

@@ -15,59 +15,59 @@ class MbusDeviceTest(unittest.TestCase):
         device_type_parser = [
             object["value_parser"]
             for object in v5_objects
-            if object["obis_reference"] == obis_references.DEVICE_TYPE
+            if object["obis_reference"] == obis_references.MBUS_DEVICE_TYPE
         ][0]
         device_type = device_type_parser.parse('0-2:24.1.0(003)\r\n')
 
         equipment_parser = [
             object["value_parser"]
             for object in v5_objects
-            if object["obis_reference"] == obis_references.EQUIPMENT_IDENTIFIER_GAS
+            if object["obis_reference"] == obis_references.MBUS_EQUIPMENT_IDENTIFIER
         ][0]
         equipment = equipment_parser.parse('0-2:96.1.0(4730303339303031393336393930363139)\r\n')
 
         gas_reading_parser = [
             object["value_parser"]
             for object in v5_objects
-            if object["obis_reference"] == obis_references.HOURLY_GAS_METER_READING
+            if object["obis_reference"] == obis_references.MBUS_METER_READING
         ][0]
         gas_reading = gas_reading_parser.parse('0-2:24.2.1(200426223001S)(00246.138*m3)\r\n')
 
-        mbus_device = MbusDevice(channel_id=1)
-        mbus_device.add(obis_references.DEVICE_TYPE, device_type, "DEVICE_TYPE")
-        mbus_device.add(obis_references.EQUIPMENT_IDENTIFIER_GAS, equipment, "EQUIPMENT_IDENTIFIER_GAS")
-        mbus_device.add(obis_references.HOURLY_GAS_METER_READING, gas_reading, "HOURLY_GAS_METER_READING")
+        mbus_device = MbusDevice(channel_id=2)
+        mbus_device.add(obis_references.MBUS_DEVICE_TYPE, device_type, "MBUS_DEVICE_TYPE")
+        mbus_device.add(obis_references.MBUS_EQUIPMENT_IDENTIFIER, equipment, "MBUS_EQUIPMENT_IDENTIFIER")
+        mbus_device.add(obis_references.MBUS_METER_READING, gas_reading, "MBUS_METER_READING")
 
         self.mbus_device = mbus_device
 
     def test_attributes(self):
-        self.assertEqual(self.mbus_device.DEVICE_TYPE.value, 3)
-        self.assertEqual(self.mbus_device.DEVICE_TYPE.unit, None)
+        self.assertEqual(self.mbus_device.MBUS_DEVICE_TYPE.value, 3)
+        self.assertEqual(self.mbus_device.MBUS_DEVICE_TYPE.unit, None)
 
-        self.assertEqual(self.mbus_device.EQUIPMENT_IDENTIFIER_GAS.value,
+        self.assertEqual(self.mbus_device.MBUS_EQUIPMENT_IDENTIFIER.value,
                          '4730303339303031393336393930363139')
-        self.assertEqual(self.mbus_device.EQUIPMENT_IDENTIFIER_GAS.unit, None)
+        self.assertEqual(self.mbus_device.MBUS_EQUIPMENT_IDENTIFIER.unit, None)
 
-        self.assertEqual(self.mbus_device.HOURLY_GAS_METER_READING.value, Decimal('246.138'))
-        self.assertEqual(self.mbus_device.HOURLY_GAS_METER_READING.unit, 'm3')
+        self.assertEqual(self.mbus_device.MBUS_METER_READING.value, Decimal('246.138'))
+        self.assertEqual(self.mbus_device.MBUS_METER_READING.unit, 'm3')
 
     def test_to_json(self):
         self.assertEqual(
             json.loads(self.mbus_device.to_json()),
             {
-                'CHANNEL_ID': 1,
-                'DEVICE_TYPE': {'value': 3, 'unit': None},
-                'EQUIPMENT_IDENTIFIER_GAS': {'value': '4730303339303031393336393930363139', 'unit': None},
-                'HOURLY_GAS_METER_READING': {'datetime': '2020-04-26T20:30:01+00:00', 'value': 246.138, 'unit': 'm3'}}
+                'CHANNEL_ID': 2,
+                'MBUS_DEVICE_TYPE': {'value': 3, 'unit': None},
+                'MBUS_EQUIPMENT_IDENTIFIER': {'value': '4730303339303031393336393930363139', 'unit': None},
+                'MBUS_METER_READING': {'datetime': '2020-04-26T20:30:01+00:00', 'value': 246.138, 'unit': 'm3'}}
         )
 
     def test_str(self):
         self.assertEqual(
             str(self.mbus_device),
             (
-                'MBUS DEVICE (channel 1)\n'
-                '\tDEVICE_TYPE: 	 3	[None]\n'
-                '\tEQUIPMENT_IDENTIFIER_GAS: 	 4730303339303031393336393930363139	[None]\n'
-                '\tHOURLY_GAS_METER_READING: 	 246.138	[m3] at 2020-04-26T20:30:01+00:00\n'
+                'MBUS DEVICE (channel 2)\n'
+                '\tMBUS_DEVICE_TYPE: 	 3	[None]\n'
+                '\tMBUS_EQUIPMENT_IDENTIFIER: 	 4730303339303031393336393930363139	[None]\n'
+                '\tMBUS_METER_READING: 	 246.138	[m3] at 2020-04-26T20:30:01+00:00\n'
             )
         )

test/objects/test_telegram.py

@@ -216,14 +216,6 @@ class TelegramTest(unittest.TestCase):
                                   value_type=Decimal,
                                   value_val=Decimal('2'))
 
-        # DEVICE_TYPE (0-x:24.1.0)
-        self.verify_telegram_item(telegram,
-                                  'DEVICE_TYPE',
-                                  object_type=CosemObject,
-                                  unit_val=None,
-                                  value_type=int,
-                                  value_val=3)
-
         # INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE (1-0:21.7.0)
         self.verify_telegram_item(telegram,
                                   'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE',
@@ -272,7 +264,15 @@ class TelegramTest(unittest.TestCase):
                                   value_type=Decimal,
                                   value_val=Decimal('0'))
 
-        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
+        # DEVICE_TYPE (0-1:24.1.0)
+        self.verify_telegram_item(telegram,
+                                  'DEVICE_TYPE',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=3)
+
+        # EQUIPMENT_IDENTIFIER_GAS (0-1:96.1.0)
         self.verify_telegram_item(telegram,
                                   'EQUIPMENT_IDENTIFIER_GAS',
                                   object_type=CosemObject,
@@ -340,28 +340,28 @@ class TelegramTest(unittest.TestCase):
         self.assertEqual(len(mbus_devices), 2)
 
         mbus_device_1 = mbus_devices[0]
-        self.assertEqual(mbus_device_1.DEVICE_TYPE.value, 3)
-        self.assertEqual(mbus_device_1.EQUIPMENT_IDENTIFIER_GAS.value, None)
-        self.assertEqual(mbus_device_1.HOURLY_GAS_METER_READING.value, Decimal('0'))
+        self.assertEqual(mbus_device_1.MBUS_DEVICE_TYPE.value, 3)
+        self.assertEqual(mbus_device_1.MBUS_EQUIPMENT_IDENTIFIER.value, None)
+        self.assertEqual(mbus_device_1.MBUS_METER_READING.value, Decimal('0'))
 
         mbus_device_2 = mbus_devices[1]
-        self.assertEqual(mbus_device_2.DEVICE_TYPE.value, 3)
-        self.assertEqual(mbus_device_2.EQUIPMENT_IDENTIFIER_GAS.value, '4730303339303031393336393930363139')
-        self.assertEqual(mbus_device_2.HOURLY_GAS_METER_READING.value, Decimal('246.138'))
+        self.assertEqual(mbus_device_2.MBUS_DEVICE_TYPE.value, 3)
+        self.assertEqual(mbus_device_2.MBUS_EQUIPMENT_IDENTIFIER.value, '4730303339303031393336393930363139')
+        self.assertEqual(mbus_device_2.MBUS_METER_READING.value, Decimal('246.138'))
 
     def test_get_mbus_device_by_channel(self):
         parser = TelegramParser(telegram_specifications.V5)
         telegram = parser.parse(TELEGRAM_V5_TWO_MBUS)
 
         mbus_device_1 = telegram.get_mbus_device_by_channel(1)
-        self.assertEqual(mbus_device_1.DEVICE_TYPE.value, 3)
-        self.assertEqual(mbus_device_1.EQUIPMENT_IDENTIFIER_GAS.value, None)
-        self.assertEqual(mbus_device_1.HOURLY_GAS_METER_READING.value, Decimal('0'))
+        self.assertEqual(mbus_device_1.MBUS_DEVICE_TYPE.value, 3)
+        self.assertEqual(mbus_device_1.MBUS_EQUIPMENT_IDENTIFIER.value, None)
+        self.assertEqual(mbus_device_1.MBUS_METER_READING.value, Decimal('0'))
 
         mbus_device_2 = telegram.get_mbus_device_by_channel(2)
-        self.assertEqual(mbus_device_2.DEVICE_TYPE.value, 3)
-        self.assertEqual(mbus_device_2.EQUIPMENT_IDENTIFIER_GAS.value, '4730303339303031393336393930363139')
-        self.assertEqual(mbus_device_2.HOURLY_GAS_METER_READING.value, Decimal('246.138'))
+        self.assertEqual(mbus_device_2.MBUS_DEVICE_TYPE.value, 3)
+        self.assertEqual(mbus_device_2.MBUS_EQUIPMENT_IDENTIFIER.value, '4730303339303031393336393930363139')
+        self.assertEqual(mbus_device_2.MBUS_METER_READING.value, Decimal('246.138'))
 
     def test_without_mbus_devices(self):
         parser = TelegramParser(telegram_specifications.V5, apply_checksum_validation=False)
@@ -375,11 +375,12 @@ class TelegramTest(unittest.TestCase):
         telegram = parser.parse(TELEGRAM_V5)
         json_data = json.loads(telegram.to_json())
 
+        self.maxDiff = None
+
         self.assertEqual(
             json_data,
             {'CURRENT_ELECTRICITY_DELIVERY': {'unit': 'kW', 'value': 0.0},
              'CURRENT_ELECTRICITY_USAGE': {'unit': 'kW', 'value': 0.244},
-             'DEVICE_TYPE': {'unit': None, 'value': 3},
              'ELECTRICITY_ACTIVE_TARIFF': {'unit': None, 'value': '0002'},
              'ELECTRICITY_DELIVERED_TARIFF_1': {'unit': 'kWh', 'value': 2.444},
              'ELECTRICITY_DELIVERED_TARIFF_2': {'unit': 'kWh', 'value': 0.0},
@@ -387,10 +388,6 @@ class TelegramTest(unittest.TestCase):
              'ELECTRICITY_USED_TARIFF_2': {'unit': 'kWh', 'value': 2.399},
              'EQUIPMENT_IDENTIFIER': {'unit': None,
                                       'value': '4B384547303034303436333935353037'},
-             'EQUIPMENT_IDENTIFIER_GAS': {'unit': None, 'value': None},
-             'HOURLY_GAS_METER_READING': {'datetime': '2017-01-02T15:10:05+00:00',
-                                          'unit': 'm3',
-                                          'value': 0.107},
              'INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE': {'unit': 'kW', 'value': 0.0},
              'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE': {'unit': 'kW', 'value': 0.07},
              'INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE': {'unit': 'kW', 'value': 0.0},
@@ -405,15 +402,16 @@ class TelegramTest(unittest.TestCase):
              'INSTANTANEOUS_VOLTAGE_L3': {'unit': 'V', 'value': 229.0},
              'LONG_POWER_FAILURE_COUNT': {'unit': None, 'value': 0},
              'MBUS_DEVICES': [{'CHANNEL_ID': 1,
-                               'DEVICE_TYPE': {'unit': None, 'value': 3},
-                               'EQUIPMENT_IDENTIFIER_GAS': {'unit': None,
-                                                            'value': '3232323241424344313233343536373839'},
-                               'HOURLY_GAS_METER_READING': {'datetime': '2017-01-02T15:10:05+00:00',
-                                                            'unit': 'm3',
-                                                            'value': 0.107}},
+                               'MBUS_DEVICE_TYPE': {'unit': None, 'value': 3},
+                               'MBUS_EQUIPMENT_IDENTIFIER': {'unit': None,
+                                                             'value': '3232323241424344313233343536373839'},
+                               'MBUS_METER_READING': {'datetime': '2017-01-02T15:10:05+00:00',
+                                                      'unit': 'm3',
+                                                      'value': 0.107}},
                               {'CHANNEL_ID': 2,
-                               'DEVICE_TYPE': {'unit': None, 'value': 3},
-                               'EQUIPMENT_IDENTIFIER_GAS': {'unit': None, 'value': None}}],
+                               'MBUS_DEVICE_TYPE': {'unit': None, 'value': 3},
+                               'MBUS_EQUIPMENT_IDENTIFIER': {'unit': None,
+                                                             'value': None}}],
              'P1_MESSAGE_HEADER': {'unit': None, 'value': '50'},
              'P1_MESSAGE_TIMESTAMP': {'unit': None, 'value': '2017-01-02T18:20:02+00:00'},
              'POWER_EVENT_FAILURE_LOG': {'buffer': [],
@@ -433,6 +431,8 @@ class TelegramTest(unittest.TestCase):
         parser = TelegramParser(telegram_specifications.V5)
         telegram = parser.parse(TELEGRAM_V5)
 
+        self.maxDiff = None
+
         self.assertEqual(
             str(telegram),
             (
@@ -463,22 +463,19 @@ class TelegramTest(unittest.TestCase):
                 'INSTANTANEOUS_CURRENT_L2: 	 0.44	[A]\n'
                 'INSTANTANEOUS_CURRENT_L3: 	 0.86	[A]\n'
                 'TEXT_MESSAGE: 	 None	[None]\n'
-                'DEVICE_TYPE: 	 3	[None]\n'
-                'MBUS DEVICE (channel 1)\n'
-                '	DEVICE_TYPE: 	 3	[None]\n'
-                '	EQUIPMENT_IDENTIFIER_GAS: 	 3232323241424344313233343536373839	[None]\n'
-                '	HOURLY_GAS_METER_READING: 	 0.107	[m3] at 2017-01-02T15:10:05+00:00\n'
-                'MBUS DEVICE (channel 2)\n'
-                '	DEVICE_TYPE: 	 3	[None]\n'
-                '	EQUIPMENT_IDENTIFIER_GAS: 	 None	[None]\n'
                 'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: 	 0.070	[kW]\n'
                 'INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE: 	 0.032	[kW]\n'
                 'INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE: 	 0.142	[kW]\n'
                 'INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE: 	 0.000	[kW]\n'
                 'INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE: 	 0.000	[kW]\n'
                 'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE: 	 0.000	[kW]\n'
-                'EQUIPMENT_IDENTIFIER_GAS: 	 None	[None]\n'
-                'HOURLY_GAS_METER_READING: 	 0.107	[m3] at 2017-01-02T15:10:05+00:00\n'
+                'MBUS DEVICE (channel 1)\n'
+                '	MBUS_DEVICE_TYPE: 	 3	[None]\n'
+                '	MBUS_EQUIPMENT_IDENTIFIER: 	 3232323241424344313233343536373839	[None]\n'
+                '	MBUS_METER_READING: 	 0.107	[m3] at 2017-01-02T15:10:05+00:00\n'
+                'MBUS DEVICE (channel 2)\n'
+                '	MBUS_DEVICE_TYPE: 	 3	[None]\n'
+                '	MBUS_EQUIPMENT_IDENTIFIER: 	 None	[None]\n'
             )
         )
 

test/test_parse_fluvius.py

@@ -211,64 +211,70 @@ class TelegramParserFluviusTest(unittest.TestCase):
         assert isinstance(result.ACTUAL_SWITCH_POSITION.value, int)
         assert result.ACTUAL_SWITCH_POSITION.value == 1
 
-        # BELGIUM_MAX_POWER_PER_PHASE (0-0:17.0.0)
-        assert isinstance(result.BELGIUM_MAX_POWER_PER_PHASE, CosemObject)
-        assert result.BELGIUM_MAX_POWER_PER_PHASE.unit == 'kW'
-        assert isinstance(result.BELGIUM_MAX_POWER_PER_PHASE.value, Decimal)
-        assert result.BELGIUM_MAX_POWER_PER_PHASE.value == Decimal('999.9')
+        # ACTUAL_TRESHOLD_ELECTRICITY (0-0:17.0.0)
+        assert isinstance(result.ACTUAL_TRESHOLD_ELECTRICITY, CosemObject)
+        assert result.ACTUAL_TRESHOLD_ELECTRICITY.unit == 'kW'
+        assert isinstance(result.ACTUAL_TRESHOLD_ELECTRICITY.value, Decimal)
+        assert result.ACTUAL_TRESHOLD_ELECTRICITY.value == Decimal('999.9')
 
-        # BELGIUM_MAX_POWER_PER_PHASE (1-0:31.4.0)
-        assert isinstance(result.BELGIUM_MAX_CURRENT_PER_PHASE, CosemObject)
-        assert result.BELGIUM_MAX_CURRENT_PER_PHASE.unit == 'A'
-        assert isinstance(result.BELGIUM_MAX_CURRENT_PER_PHASE.value, Decimal)
-        assert result.BELGIUM_MAX_CURRENT_PER_PHASE.value == Decimal('999')
+        # FUSE_THRESHOLD_L1 (1-0:31.4.0)
+        assert isinstance(result.FUSE_THRESHOLD_L1, CosemObject)
+        assert result.FUSE_THRESHOLD_L1.unit == 'A'
+        assert isinstance(result.FUSE_THRESHOLD_L1.value, Decimal)
+        assert result.FUSE_THRESHOLD_L1.value == Decimal('999')
 
         # TEXT_MESSAGE (0-0:96.13.0)
         assert isinstance(result.TEXT_MESSAGE, CosemObject)
         assert result.TEXT_MESSAGE.unit is None
         assert result.TEXT_MESSAGE.value is None
 
-        # BELGIUM_MBUS1_DEVICE_TYPE (0-1:24.1.0)
-        assert isinstance(result.BELGIUM_MBUS1_DEVICE_TYPE, CosemObject)
-        assert result.BELGIUM_MBUS1_DEVICE_TYPE.unit is None
-        assert isinstance(result.BELGIUM_MBUS1_DEVICE_TYPE.value, int)
-        assert result.BELGIUM_MBUS1_DEVICE_TYPE.value == 3
+        # MBUS DEVICE 1
+        mbus1 = result.get_mbus_device_by_channel(1)
 
-        # BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER (0-1:96.1.1)
-        assert isinstance(result.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER, CosemObject)
-        assert result.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER.unit is None
-        assert isinstance(result.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER.value, str)
-        assert result.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER.value == '37464C4F32313139303333373333'
+        # MBUS_DEVICE_TYPE (0-1:24.1.0)
+        assert isinstance(mbus1.MBUS_DEVICE_TYPE, CosemObject)
+        assert mbus1.MBUS_DEVICE_TYPE.unit is None
+        assert isinstance(mbus1.MBUS_DEVICE_TYPE.value, int)
+        assert mbus1.MBUS_DEVICE_TYPE.value == 3
 
-        # BELGIUM_MBUS1_VALVE_POSITION (0-1:24.4.0)
-        assert isinstance(result.BELGIUM_MBUS1_VALVE_POSITION, CosemObject)
-        assert result.BELGIUM_MBUS1_VALVE_POSITION.unit is None
-        assert isinstance(result.BELGIUM_MBUS1_VALVE_POSITION.value, int)
-        assert result.BELGIUM_MBUS1_VALVE_POSITION.value == 1
+        # MBUS_EQUIPMENT_IDENTIFIER (0-1:96.1.1)
+        assert isinstance(mbus1.MBUS_EQUIPMENT_IDENTIFIER, CosemObject)
+        assert mbus1.MBUS_EQUIPMENT_IDENTIFIER.unit is None
+        assert isinstance(mbus1.MBUS_EQUIPMENT_IDENTIFIER.value, str)
+        assert mbus1.MBUS_EQUIPMENT_IDENTIFIER.value == '37464C4F32313139303333373333'
 
-        # BELGIUM_MBUS1_METER_READING2 (0-1:24.2.3)
-        assert isinstance(result.BELGIUM_MBUS1_METER_READING2, MBusObject)
-        assert result.BELGIUM_MBUS1_METER_READING2.unit == 'm3'
-        assert isinstance(result.BELGIUM_MBUS1_METER_READING2.value, Decimal)
-        assert result.BELGIUM_MBUS1_METER_READING2.value == Decimal('112.384')
+        # MBUS_VALVE_POSITION (0-1:24.4.0)
+        assert isinstance(result.MBUS_VALVE_POSITION, CosemObject)
+        assert result.MBUS_VALVE_POSITION.unit is None
+        assert isinstance(result.MBUS_VALVE_POSITION.value, int)
+        assert result.MBUS_VALVE_POSITION.value == 1
 
-        # BELGIUM_MBUS2_DEVICE_TYPE (0-2:24.1.0)
-        assert isinstance(result.BELGIUM_MBUS2_DEVICE_TYPE, CosemObject)
-        assert result.BELGIUM_MBUS2_DEVICE_TYPE.unit is None
-        assert isinstance(result.BELGIUM_MBUS2_DEVICE_TYPE.value, int)
-        assert result.BELGIUM_MBUS2_DEVICE_TYPE.value == 7
+        # MBUS_METER_READING (0-1:24.2.3)
+        assert isinstance(mbus1.MBUS_METER_READING, MBusObject)
+        assert mbus1.MBUS_METER_READING.unit == 'm3'
+        assert isinstance(mbus1.MBUS_METER_READING.value, Decimal)
+        assert mbus1.MBUS_METER_READING.value == Decimal('112.384')
 
-        # BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER (0-2:96.1.1)
-        assert isinstance(result.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER, CosemObject)
-        assert result.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER.unit is None
-        assert isinstance(result.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER.value, str)
-        assert result.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER.value == '3853414731323334353637383930'
+        # MBUS DEVICE 2
+        mbus2 = result.get_mbus_device_by_channel(2)
 
-        # BELGIUM_MBUS2_METER_READING1 (0-1:24.2.1)
-        assert isinstance(result.BELGIUM_MBUS2_METER_READING1, MBusObject)
-        assert result.BELGIUM_MBUS2_METER_READING1.unit == 'm3'
-        assert isinstance(result.BELGIUM_MBUS2_METER_READING1.value, Decimal)
-        assert result.BELGIUM_MBUS2_METER_READING1.value == Decimal('872.234')
+        # MBUS_DEVICE_TYPE (0-2:24.1.0)
+        assert isinstance(mbus2.MBUS_DEVICE_TYPE, CosemObject)
+        assert mbus2.MBUS_DEVICE_TYPE.unit is None
+        assert isinstance(mbus2.MBUS_DEVICE_TYPE.value, int)
+        assert mbus2.MBUS_DEVICE_TYPE.value == 7
+
+        # MBUS_EQUIPMENT_IDENTIFIER (0-2:96.1.1)
+        assert isinstance(mbus2.MBUS_EQUIPMENT_IDENTIFIER, CosemObject)
+        assert mbus2.MBUS_EQUIPMENT_IDENTIFIER.unit is None
+        assert isinstance(mbus2.MBUS_EQUIPMENT_IDENTIFIER.value, str)
+        assert mbus2.MBUS_EQUIPMENT_IDENTIFIER.value == '3853414731323334353637383930'
+
+        # MBUS_METER_READING (0-1:24.2.1)
+        assert isinstance(mbus2.MBUS_METER_READING, MBusObject)
+        assert mbus2.MBUS_METER_READING.unit == 'm3'
+        assert isinstance(mbus2.MBUS_METER_READING.value, Decimal)
+        assert mbus2.MBUS_METER_READING.value == Decimal('872.234')
 
     def test_checksum_valid(self):
         # No exception is raised.
@@ -296,6 +302,8 @@ class TelegramParserFluviusTest(unittest.TestCase):
         telegram = parser.parse(TELEGRAM_FLUVIUS_V171_ALT)
         json_data = json.loads(telegram.to_json())
 
+        self.maxDiff = None
+
         self.assertEqual(
             json_data,
             {'BELGIUM_VERSION_INFORMATION': {'value': '50217', 'unit': None},
@@ -336,29 +344,21 @@ class TelegramParserFluviusTest(unittest.TestCase):
              'INSTANTANEOUS_CURRENT_L3': {'value': 0.52, 'unit': 'A'},
              'ACTUAL_SWITCH_POSITION': {'value': 1, 'unit': None},
              'ACTUAL_TRESHOLD_ELECTRICITY': {'value': 999.9, 'unit': 'kW'},
-             'BELGIUM_MAX_POWER_PER_PHASE': {'value': 999.9, 'unit': 'kW'},
-             'BELGIUM_MAX_CURRENT_PER_PHASE': {'value': 999.0, 'unit': 'A'},
+             'FUSE_THRESHOLD_L1': {'value': 999.0, 'unit': 'A'},
              'TEXT_MESSAGE': {'value': None, 'unit': None},
-             'BELGIUM_MBUS1_DEVICE_TYPE': {'value': 3, 'unit': None},
-             'MBUS_DEVICES': [{'BELGIUM_MBUS1_DEVICE_TYPE': {'value': 3, 'unit': None},
-                               'BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER': {'value': '37464C4F32313233303838303237',
+             'MBUS_DEVICES': [{'MBUS_DEVICE_TYPE': {'value': 3, 'unit': None},
+                               'MBUS_EQUIPMENT_IDENTIFIER': {'value': '37464C4F32313233303838303237',
                                                                       'unit': None},
-                               'BELGIUM_MBUS1_VALVE_POSITION': {'value': 1, 'unit': None},
-                               'BELGIUM_MBUS1_METER_READING2': {'datetime': '2023-11-02T11:10:02+00:00',
-                                                                'value': 92.287, 'unit': 'm3'},
+                               'MBUS_VALVE_POSITION': {'value': 1, 'unit': None},
+                               'MBUS_METER_READING': {'datetime': '2023-11-02T11:10:02+00:00',
+                                                                  'value': 92.287, 'unit': 'm3'},
                                'CHANNEL_ID': 1},
-                              {'BELGIUM_MBUS2_DEVICE_TYPE': {'value': 7, 'unit': None},
-                               'BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER': {'value': '3853455430303030393631313733',
+                              {'MBUS_DEVICE_TYPE': {'value': 7, 'unit': None},
+                               'MBUS_EQUIPMENT_IDENTIFIER': {'value': '3853455430303030393631313733',
                                                                       'unit': None},
-                               'BELGIUM_MBUS2_METER_READING1': {'datetime': '2023-11-02T11:15:32+00:00',
-                                                                'value': 8.579, 'unit': 'm3'},
-                               'CHANNEL_ID': 2}],
-             'BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER': {'value': '37464C4F32313233303838303237', 'unit': None},
-             'BELGIUM_MBUS1_VALVE_POSITION': {'value': 1, 'unit': None},
-             'BELGIUM_MBUS1_METER_READING2': {'datetime': '2023-11-02T11:10:02+00:00', 'value': 92.287, 'unit': 'm3'},
-             'BELGIUM_MBUS2_DEVICE_TYPE': {'value': 7, 'unit': None},
-             'BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER': {'value': '3853455430303030393631313733', 'unit': None},
-             'BELGIUM_MBUS2_METER_READING1': {'datetime': '2023-11-02T11:15:32+00:00', 'value': 8.579, 'unit': 'm3'}}
+                               'MBUS_METER_READING': {'datetime': '2023-11-02T11:15:32+00:00',
+                                                                  'value': 8.579, 'unit': 'm3'},
+                               'CHANNEL_ID': 2}]}
         )
 
     def test_to_str(self):
@@ -398,24 +398,16 @@ class TelegramParserFluviusTest(unittest.TestCase):
                 'INSTANTANEOUS_CURRENT_L3: 	 0.52	[A]\n'
                 'ACTUAL_SWITCH_POSITION: 	 1	[None]\n'
                 'ACTUAL_TRESHOLD_ELECTRICITY: 	 999.9	[kW]\n'
-                'BELGIUM_MAX_POWER_PER_PHASE: 	 999.9	[kW]\n'
-                'BELGIUM_MAX_CURRENT_PER_PHASE: 	 999	[A]\n'
+                'FUSE_THRESHOLD_L1: 	 999	[A]\n'
                 'TEXT_MESSAGE: 	 None	[None]\n'
-                'BELGIUM_MBUS1_DEVICE_TYPE: 	 3	[None]\n'
                 'MBUS DEVICE (channel 1)\n'
-                '	BELGIUM_MBUS1_DEVICE_TYPE: 	 3	[None]\n'
-                '	BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER: 	 37464C4F32313233303838303237	[None]\n'
-                '	BELGIUM_MBUS1_VALVE_POSITION: 	 1	[None]\n'
-                '	BELGIUM_MBUS1_METER_READING2: 	 92.287	[m3] at 2023-11-02T11:10:02+00:00\n'
+                '	MBUS_DEVICE_TYPE: 	 3	[None]\n'
+                '	MBUS_EQUIPMENT_IDENTIFIER: 	 37464C4F32313233303838303237	[None]\n'
+                '	MBUS_VALVE_POSITION: 	 1	[None]\n'
+                '	MBUS_METER_READING: 	 92.287	[m3] at 2023-11-02T11:10:02+00:00\n'
                 'MBUS DEVICE (channel 2)\n'
-                '	BELGIUM_MBUS2_DEVICE_TYPE: 	 7	[None]\n'
-                '	BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER: 	 3853455430303030393631313733	[None]\n'
-                '	BELGIUM_MBUS2_METER_READING1: 	 8.579	[m3] at 2023-11-02T11:15:32+00:00\n'
-                'BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER: 	 37464C4F32313233303838303237	[None]\n'
-                'BELGIUM_MBUS1_VALVE_POSITION: 	 1	[None]\n'
-                'BELGIUM_MBUS1_METER_READING2: 	 92.287	[m3] at 2023-11-02T11:10:02+00:00\n'
-                'BELGIUM_MBUS2_DEVICE_TYPE: 	 7	[None]\n'
-                'BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER: 	 3853455430303030393631313733	[None]\n'
-                'BELGIUM_MBUS2_METER_READING1: 	 8.579	[m3] at 2023-11-02T11:15:32+00:00\n'
+                '	MBUS_DEVICE_TYPE: 	 7	[None]\n'
+                '	MBUS_EQUIPMENT_IDENTIFIER: 	 3853455430303030393631313733	[None]\n'
+                '	MBUS_METER_READING: 	 8.579	[m3] at 2023-11-02T11:15:32+00:00\n'
             )
         )

test/test_parse_v5.py

@@ -21,7 +21,7 @@ class TelegramParserV5Test(unittest.TestCase):
             telegram = parser.parse(TELEGRAM_V5, throw_ex=True)
         except Exception as ex:
             assert False, f"parse trigged an exception {ex}"
-        print('test: ', type(telegram.P1_MESSAGE_HEADER), telegram.P1_MESSAGE_HEADER.__dict__)
+
         # P1_MESSAGE_HEADER (1-3:0.2.8)
         assert isinstance(telegram.P1_MESSAGE_HEADER, CosemObject)
         assert telegram.P1_MESSAGE_HEADER.unit is None
@@ -172,12 +172,6 @@ class TelegramParserV5Test(unittest.TestCase):
         assert telegram.TEXT_MESSAGE.unit is None
         assert telegram.TEXT_MESSAGE.value is None
 
-        # DEVICE_TYPE (0-x:24.1.0)
-        assert isinstance(telegram.DEVICE_TYPE, CosemObject)
-        assert telegram.DEVICE_TYPE.unit is None
-        assert isinstance(telegram.DEVICE_TYPE.value, int)
-        assert telegram.DEVICE_TYPE.value == 3
-
         # INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE (1-0:21.7.0)
         assert isinstance(telegram.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE, CosemObject)
         assert telegram.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE.unit == 'kW'
@@ -215,27 +209,27 @@ class TelegramParserV5Test(unittest.TestCase):
         assert telegram.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE.value == Decimal('0')
 
         # There's only one Mbus device (gas meter) in this case. Alternatively
-        # use get_mbget_mbus_device_by_channel
+        # use get_mbus_device_by_channel
         gas_meter_devices = telegram.MBUS_DEVICES
         gas_meter_device = gas_meter_devices[0]
 
-        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
-        assert isinstance(gas_meter_device.DEVICE_TYPE, CosemObject)
-        assert gas_meter_device.DEVICE_TYPE.unit is None
-        assert isinstance(gas_meter_device.DEVICE_TYPE.value, int)
-        assert gas_meter_device.DEVICE_TYPE.value == 3
+        # MBUS_DEVICE_TYPE (0-1:96.1.0)
+        assert isinstance(gas_meter_device.MBUS_DEVICE_TYPE, CosemObject)
+        assert gas_meter_device.MBUS_DEVICE_TYPE.unit is None
+        assert isinstance(gas_meter_device.MBUS_DEVICE_TYPE.value, int)
+        assert gas_meter_device.MBUS_DEVICE_TYPE.value == 3
 
-        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
-        assert isinstance(gas_meter_device.EQUIPMENT_IDENTIFIER_GAS, CosemObject)
-        assert gas_meter_device.EQUIPMENT_IDENTIFIER_GAS.unit is None
-        assert isinstance(gas_meter_device.EQUIPMENT_IDENTIFIER_GAS.value, str)
-        assert gas_meter_device.EQUIPMENT_IDENTIFIER_GAS.value == '3232323241424344313233343536373839'
+        # MBUS_EQUIPMENT_IDENTIFIER (0-1:96.1.0)
+        assert isinstance(gas_meter_device.MBUS_EQUIPMENT_IDENTIFIER, CosemObject)
+        assert gas_meter_device.MBUS_EQUIPMENT_IDENTIFIER.unit is None
+        assert isinstance(gas_meter_device.MBUS_EQUIPMENT_IDENTIFIER.value, str)
+        assert gas_meter_device.MBUS_EQUIPMENT_IDENTIFIER.value == '3232323241424344313233343536373839'
 
-        # HOURLY_GAS_METER_READING (0-1:24.2.1)
-        assert isinstance(gas_meter_device.HOURLY_GAS_METER_READING, MBusObject)
-        assert gas_meter_device.HOURLY_GAS_METER_READING.unit == 'm3'
-        assert isinstance(telegram.HOURLY_GAS_METER_READING.value, Decimal)
-        assert gas_meter_device.HOURLY_GAS_METER_READING.value == Decimal('0.107')
+        # MBUS_METER_READING (0-1:24.2.1)
+        assert isinstance(gas_meter_device.MBUS_METER_READING, MBusObject)
+        assert gas_meter_device.MBUS_METER_READING.unit == 'm3'
+        assert isinstance(telegram.MBUS_METER_READING.value, Decimal)
+        assert gas_meter_device.MBUS_METER_READING.value == Decimal('0.107')
 
     def test_checksum_valid(self):
         # No exception is raised.
@@ -270,8 +264,11 @@ class TelegramParserV5Test(unittest.TestCase):
         parser = TelegramParser(telegram_specifications.V5)
         telegram = parser.parse(invalid_date_telegram)
 
-        # HOURLY_GAS_METER_READING (0-1:24.2.1)
-        assert isinstance(telegram.HOURLY_GAS_METER_READING, MBusObject)
-        assert telegram.HOURLY_GAS_METER_READING.unit is None
-        assert isinstance(telegram.HOURLY_GAS_METER_READING.value, Decimal)
-        assert telegram.HOURLY_GAS_METER_READING.value == Decimal('0.000')
+        # MBUS DEVICE 1
+        mbus1 = telegram.get_mbus_device_by_channel(1)
+
+        # MBUS_METER_READING (0-1:24.2.1)
+        assert isinstance(mbus1.MBUS_METER_READING, MBusObject)
+        assert mbus1.MBUS_METER_READING.unit is None
+        assert isinstance(mbus1.MBUS_METER_READING.value, Decimal)
+        assert mbus1.MBUS_METER_READING.value == Decimal('0.000')

test/test_parse_v5_eon_hungary.py

@@ -263,23 +263,23 @@ class TelegramParserV5EONHUTest(unittest.TestCase):
         assert isinstance(telegram.INSTANTANEOUS_REACTIVE_POWER_Q4.value, Decimal)
         assert telegram.INSTANTANEOUS_REACTIVE_POWER_Q4.value == Decimal('00.000')
 
-        # EON_HU_MAX_POWER_ON_L1 (1-0:31.4.0)
-        assert isinstance(telegram.MAX_POWER_ON_L1, CosemObject)
-        assert telegram.MAX_POWER_ON_L1.unit == 'A'
-        assert isinstance(telegram.MAX_POWER_ON_L1.value, Decimal)
-        assert telegram.MAX_POWER_ON_L1.value == Decimal('200.00')
+        # FUSE_THRESHOLD_L1 (1-0:31.4.0)
+        assert isinstance(telegram.FUSE_THRESHOLD_L1, CosemObject)
+        assert telegram.FUSE_THRESHOLD_L1.unit == 'A'
+        assert isinstance(telegram.FUSE_THRESHOLD_L1.value, Decimal)
+        assert telegram.FUSE_THRESHOLD_L1.value == Decimal('200.00')
 
-        # EON_HU_MAX_POWER_ON_L2 (1-0:31.4.0)
-        assert isinstance(telegram.MAX_POWER_ON_L2, CosemObject)
-        assert telegram.MAX_POWER_ON_L2.unit == 'A'
-        assert isinstance(telegram.MAX_POWER_ON_L2.value, Decimal)
-        assert telegram.MAX_POWER_ON_L2.value == Decimal('200.00')
+        # FUSE_THRESHOLD_L2 (1-0:31.4.0)
+        assert isinstance(telegram.FUSE_THRESHOLD_L2, CosemObject)
+        assert telegram.FUSE_THRESHOLD_L2.unit == 'A'
+        assert isinstance(telegram.FUSE_THRESHOLD_L2.value, Decimal)
+        assert telegram.FUSE_THRESHOLD_L2.value == Decimal('200.00')
 
-        # EON_HU_MAX_POWER_ON_L3 (1-0:31.4.0)
-        assert isinstance(telegram.MAX_POWER_ON_L3, CosemObject)
-        assert telegram.MAX_POWER_ON_L3.unit == 'A'
-        assert isinstance(telegram.MAX_POWER_ON_L3.value, Decimal)
-        assert telegram.MAX_POWER_ON_L3.value == Decimal('200.00')
+        # FUSE_THRESHOLD_L3 (1-0:31.4.0)
+        assert isinstance(telegram.FUSE_THRESHOLD_L3, CosemObject)
+        assert telegram.FUSE_THRESHOLD_L3.unit == 'A'
+        assert isinstance(telegram.FUSE_THRESHOLD_L3.value, Decimal)
+        assert telegram.FUSE_THRESHOLD_L3.value == Decimal('200.00')
 
         # TEXT_MESSAGE (0-0:96.13.0)
         assert isinstance(telegram.TEXT_MESSAGE, CosemObject)

test/test_protocol.py

@@ -68,6 +68,6 @@ class ProtocolTest(unittest.TestCase):
 
         # 2nd call of keep_alive should close the transport
         self.protocol.keep_alive()
-        assert mock_transport.close.called_once()
+        mock_transport.close.assert_called_once()
 
         self.protocol.connection_lost(None)

tox.ini

@@ -6,6 +6,7 @@ deps=
   pytest-asyncio
   pytest-mock
   dlms_cosem
+  setuptools
 commands=
   py.test --cov=dsmr_parser test {posargs}
   pylama dsmr_parser test
@@ -13,6 +14,9 @@ commands=
 [pylama:dsmr_parser/clients/__init__.py]
 ignore = W0611
 
+[pylama:dsmr_parser/clients/socket_.py]
+ignore = C901
+
 [pylama:dsmr_parser/parsers.py]
 ignore = W605
 
@@ -23,4 +27,4 @@ ignore = E501
 max_line_length = 120
 
 [pylama:pycodestyle]
-max_line_length = 120
+max_line_length = 120