add workflow test for python 3.12

This commit removes BELGIUM_MAX_POWER_PER_PHASE and uses
ACTUAL_TRESHOLD_ELECTRICITY as this has same regex. So useless to keep
the BELIUM variant.

.github/workflows/tests.yml

@@ -17,6 +17,7 @@ jobs:
           - '3.9'
           - '3.10'
           - '3.11'
+          - '3.12'
 
     name: Python ${{ matrix.python-version }}
     steps:

CHANGELOG.rst

@@ -1,6 +1,15 @@
 Change Log
 ----------
 
+**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>`_)
+
+**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>`_)
+
 **1.2.4** (2023-07-11)
 
 - EQUIPMENT IDENTIFIER is wrong for Fluvius meters when other mbus devices are present

dsmr_parser/clients/protocol.py

@@ -21,7 +21,9 @@ def create_dsmr_protocol(dsmr_version, telegram_callback, loop=None, **kwargs):
     return protocol
 
 
-def _create_dsmr_protocol(dsmr_version, telegram_callback, protocol, loop=None, **kwargs):
+# pylama noqa - because of "complex" (too long) if-elif-else.
+# Match - case might be a solution but it is not available in <3.10
+def _create_dsmr_protocol(dsmr_version, telegram_callback, protocol, loop=None, **kwargs): #noqa
     """Creates a DSMR asyncio protocol."""
 
     if dsmr_version == '2.2':

dsmr_parser/obis_name_mapping.py

@@ -1,120 +0,0 @@
-from dsmr_parser import obis_references as obis
-
-"""
-dsmr_parser.obis_name_mapping
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-This module contains a mapping of obis references to names.
-"""
-
-EN = {
-    obis.P1_MESSAGE_HEADER: 'P1_MESSAGE_HEADER',
-    obis.P1_MESSAGE_TIMESTAMP: 'P1_MESSAGE_TIMESTAMP',
-    obis.ELECTRICITY_IMPORTED_TOTAL: 'ELECTRICITY_IMPORTED_TOTAL',
-    obis.ELECTRICITY_REACTIVE_IMPORTED_TOTAL: 'ELECTRICITY_REACTIVE_IMPORTED_TOTAL',
-    obis.ELECTRICITY_USED_TARIFF_1: 'ELECTRICITY_USED_TARIFF_1',
-    obis.ELECTRICITY_USED_TARIFF_2: 'ELECTRICITY_USED_TARIFF_2',
-    obis.ELECTRICITY_EXPORTED_TOTAL: 'ELECTRICITY_EXPORTED_TOTAL',
-    obis.ELECTRICITY_REACTIVE_EXPORTED_TOTAL: 'ELECTRICITY_REACTIVE_EXPORTED_TOTAL',
-    obis.ELECTRICITY_DELIVERED_TARIFF_1: 'ELECTRICITY_DELIVERED_TARIFF_1',
-    obis.ELECTRICITY_DELIVERED_TARIFF_2: 'ELECTRICITY_DELIVERED_TARIFF_2',
-    obis.ELECTRICITY_ACTIVE_TARIFF: 'ELECTRICITY_ACTIVE_TARIFF',
-    obis.CURRENT_REACTIVE_EXPORTED: 'CURRENT_REACTIVE_EXPORTED',
-    obis.ELECTRICITY_REACTIVE_IMPORTED_TARIFF_1: 'ELECTRICITY_REACTIVE_IMPORTED_TARIFF_1',
-    obis.ELECTRICITY_REACTIVE_IMPORTED_TARIFF_2: 'ELECTRICITY_REACTIVE_IMPORTED_TARIFF_2',
-    obis.ELECTRICITY_REACTIVE_EXPORTED_TARIFF_1: 'ELECTRICITY_REACTIVE_EXPORTED_TARIFF_1',
-    obis.ELECTRICITY_REACTIVE_EXPORTED_TARIFF_2: 'ELECTRICITY_REACTIVE_EXPORTED_TARIFF_2',
-    obis.CURRENT_REACTIVE_IMPORTED: 'CURRENT_REACTIVE_IMPORTED',
-    obis.EQUIPMENT_IDENTIFIER: 'EQUIPMENT_IDENTIFIER',
-    obis.CURRENT_ELECTRICITY_USAGE: 'CURRENT_ELECTRICITY_USAGE',
-    obis.CURRENT_ELECTRICITY_DELIVERY: 'CURRENT_ELECTRICITY_DELIVERY',
-    obis.LONG_POWER_FAILURE_COUNT: 'LONG_POWER_FAILURE_COUNT',
-    obis.SHORT_POWER_FAILURE_COUNT: 'SHORT_POWER_FAILURE_COUNT',
-    obis.POWER_EVENT_FAILURE_LOG: 'POWER_EVENT_FAILURE_LOG',
-    obis.VOLTAGE_SAG_L1_COUNT: 'VOLTAGE_SAG_L1_COUNT',
-    obis.VOLTAGE_SAG_L2_COUNT: 'VOLTAGE_SAG_L2_COUNT',
-    obis.VOLTAGE_SAG_L3_COUNT: 'VOLTAGE_SAG_L3_COUNT',
-    obis.VOLTAGE_SWELL_L1_COUNT: 'VOLTAGE_SWELL_L1_COUNT',
-    obis.VOLTAGE_SWELL_L2_COUNT: 'VOLTAGE_SWELL_L2_COUNT',
-    obis.VOLTAGE_SWELL_L3_COUNT: 'VOLTAGE_SWELL_L3_COUNT',
-    obis.INSTANTANEOUS_VOLTAGE_L1: 'INSTANTANEOUS_VOLTAGE_L1',
-    obis.INSTANTANEOUS_VOLTAGE_L2: 'INSTANTANEOUS_VOLTAGE_L2',
-    obis.INSTANTANEOUS_VOLTAGE_L3: 'INSTANTANEOUS_VOLTAGE_L3',
-    obis.INSTANTANEOUS_CURRENT_L1: 'INSTANTANEOUS_CURRENT_L1',
-    obis.INSTANTANEOUS_CURRENT_L2: 'INSTANTANEOUS_CURRENT_L2',
-    obis.INSTANTANEOUS_CURRENT_L3: 'INSTANTANEOUS_CURRENT_L3',
-    obis.TEXT_MESSAGE_CODE: 'TEXT_MESSAGE_CODE',
-    obis.TEXT_MESSAGE: 'TEXT_MESSAGE',
-    obis.DEVICE_TYPE: 'DEVICE_TYPE',
-    obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: 'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE',
-    obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE: 'INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE',
-    obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE: 'INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE',
-    obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE: 'INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE',
-    obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE: 'INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE',
-    obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE: 'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE',
-    obis.INSTANTANEOUS_REACTIVE_POWER_L1_POSITIVE: 'INSTANTANEOUS_REACTIVE_POWER_L1_POSITIVE',
-    obis.INSTANTANEOUS_REACTIVE_POWER_L1_NEGATIVE: 'INSTANTANEOUS_REACTIVE_POWER_L1_NEGATIVE',
-    obis.INSTANTANEOUS_REACTIVE_POWER_L2_POSITIVE: 'INSTANTANEOUS_REACTIVE_POWER_L2_POSITIVE',
-    obis.INSTANTANEOUS_REACTIVE_POWER_L2_NEGATIVE: 'INSTANTANEOUS_REACTIVE_POWER_L2_NEGATIVE',
-    obis.INSTANTANEOUS_REACTIVE_POWER_L3_POSITIVE: 'INSTANTANEOUS_REACTIVE_POWER_L3_POSITIVE',
-    obis.INSTANTANEOUS_REACTIVE_POWER_L3_NEGATIVE: 'INSTANTANEOUS_REACTIVE_POWER_L3_NEGATIVE',
-    obis.EQUIPMENT_IDENTIFIER_GAS: 'EQUIPMENT_IDENTIFIER_GAS',
-    obis.HOURLY_GAS_METER_READING: 'HOURLY_GAS_METER_READING',
-    obis.GAS_METER_READING: 'GAS_METER_READING',
-    obis.ACTUAL_TRESHOLD_ELECTRICITY: 'ACTUAL_TRESHOLD_ELECTRICITY',
-    obis.ACTUAL_SWITCH_POSITION: 'ACTUAL_SWITCH_POSITION',
-    obis.VALVE_POSITION_GAS: 'VALVE_POSITION_GAS',
-    obis.BELGIUM_VERSION_INFORMATION: 'BELGIUM_VERSION_INFORMATION',
-    obis.BELGIUM_EQUIPMENT_IDENTIFIER: 'BELGIUM_EQUIPMENT_IDENTIFIER',
-    obis.BELGIUM_CURRENT_AVERAGE_DEMAND: 'BELGIUM_CURRENT_AVERAGE_DEMAND',
-    obis.BELGIUM_MAXIMUM_DEMAND_MONTH: 'BELGIUM_MAXIMUM_DEMAND_MONTH',
-    obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS: 'BELGIUM_MAXIMUM_DEMAND_13_MONTHS',
-    obis.BELGIUM_MAX_POWER_PER_PHASE: 'BELGIUM_MAX_POWER_PER_PHASE',
-    obis.BELGIUM_MAX_CURRENT_PER_PHASE: 'BELGIUM_MAX_CURRENT_PER_PHASE',
-    obis.BELGIUM_MBUS1_DEVICE_TYPE: 'BELGIUM_MBUS1_DEVICE_TYPE',
-    obis.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER: 'BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER',
-    obis.BELGIUM_MBUS1_VALVE_POSITION: 'BELGIUM_MBUS1_VALVE_POSITION',
-    obis.BELGIUM_MBUS1_METER_READING1: 'BELGIUM_MBUS1_METER_READING1',
-    obis.BELGIUM_MBUS1_METER_READING2: 'BELGIUM_MBUS1_METER_READING2',
-    obis.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER: 'BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER',
-    obis.BELGIUM_MBUS2_VALVE_POSITION: 'BELGIUM_MBUS2_VALVE_POSITION',
-    obis.BELGIUM_MBUS2_METER_READING1: 'BELGIUM_MBUS2_METER_READING1',
-    obis.BELGIUM_MBUS2_METER_READING2: 'BELGIUM_MBUS2_METER_READING2',
-    obis.BELGIUM_MBUS3_EQUIPMENT_IDENTIFIER: 'BELGIUM_MBUS3_EQUIPMENT_IDENTIFIER',
-    obis.BELGIUM_MBUS3_VALVE_POSITION: 'BELGIUM_MBUS3_VALVE_POSITION',
-    obis.BELGIUM_MBUS3_METER_READING1: 'BELGIUM_MBUS3_METER_READING1',
-    obis.BELGIUM_MBUS3_METER_READING2: 'BELGIUM_MBUS3_METER_READING2',
-    obis.BELGIUM_MBUS4_EQUIPMENT_IDENTIFIER: 'BELGIUM_MBUS4_EQUIPMENT_IDENTIFIER',
-    obis.BELGIUM_MBUS4_VALVE_POSITION: 'BELGIUM_MBUS4_VALVE_POSITION',
-    obis.BELGIUM_MBUS4_METER_READING1: 'BELGIUM_MBUS4_METER_READING1',
-    obis.BELGIUM_MBUS4_METER_READING2: 'BELGIUM_MBUS4_METER_READING2',
-    obis.LUXEMBOURG_EQUIPMENT_IDENTIFIER: 'LUXEMBOURG_EQUIPMENT_IDENTIFIER',
-    obis.Q3D_EQUIPMENT_IDENTIFIER: 'Q3D_EQUIPMENT_IDENTIFIER',
-    obis.Q3D_EQUIPMENT_STATE: 'Q3D_EQUIPMENT_STATE',
-    obis.Q3D_EQUIPMENT_SERIALNUMBER: 'Q3D_EQUIPMENT_SERIALNUMBER',
-    obis.BELGIUM_MBUS2_DEVICE_TYPE: 'BELGIUM_MBUS2_DEVICE_TYPE',
-    obis.EON_HU_ELECTRICITY_DELIVERED_TARIFF_3: 'EON_HU_ELECTRICITY_DELIVERED_TARIFF_3',
-    obis.EON_HU_ELECTRICITY_DELIVERED_TARIFF_4: 'EON_HU_ELECTRICITY_DELIVERED_TARIFF_4',
-    obis.EON_HU_ELECTRICITY_USED_TARIFF_3: 'EON_HU_ELECTRICITY_USED_TARIFF_3',
-    obis.EON_HU_ELECTRICITY_USED_TARIFF_4: 'EON_HU_ELECTRICITY_USED_TARIFF_4',
-    obis.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q1: 'EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q1',
-    obis.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q2: 'EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q2',
-    obis.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q3: 'EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q3',
-    obis.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q4: 'EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q4',
-    obis.EON_HU_ELECTRICITY_COMBINED: 'EON_HU_ELECTRICITY_COMBINED',
-    obis.EON_HU_INSTANTANEOUS_POWER_FACTOR_TOTAL: 'EON_HU_INSTANTANEOUS_POWER_FACTOR_TOTAL',
-    obis.EON_HU_INSTANTANEOUS_POWER_FACTOR_L1: 'EON_HU_INSTANTANEOUS_POWER_FACTOR_L1',
-    obis.EON_HU_INSTANTANEOUS_POWER_FACTOR_L2: 'EON_HU_INSTANTANEOUS_POWER_FACTOR_L2',
-    obis.EON_HU_INSTANTANEOUS_POWER_FACTOR_L3: 'EON_HU_INSTANTANEOUS_POWER_FACTOR_L3',
-    obis.EON_HU_FREQUENCY: 'EON_HU_FREQUENCY',
-    obis.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q1: 'EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q1',
-    obis.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q2: 'EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q2',
-    obis.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q3: 'EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q3',
-    obis.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q4: 'EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q4',
-    obis.EON_HU_MAX_POWER_ON_L1: 'EON_HU_MAX_POWER_ON_L1',
-    obis.EON_HU_MAX_POWER_ON_L2: 'EON_HU_MAX_POWER_ON_L2',
-    obis.EON_HU_MAX_POWER_ON_L3: 'EON_HU_MAX_POWER_ON_L3',
-    obis.EON_HU_LAST_MONTH_DATA: 'EON_HU_LAST_MONTH_DATA'
-}
-
-REVERSE_EN = dict([(v, k) for k, v in EN.items()])

dsmr_parser/obis_references.py

@@ -10,8 +10,12 @@ P1_MESSAGE_HEADER = r'^\d-\d:0\.2\.8.+?\r\n'
 P1_MESSAGE_TIMESTAMP = r'^\d-\d:1\.0\.0.+?\r\n'
 ELECTRICITY_USED_TARIFF_1 = r'^\d-\d:1\.8\.1.+?\r\n'
 ELECTRICITY_USED_TARIFF_2 = r'^\d-\d:1\.8\.2.+?\r\n'
+ELECTRICITY_USED_TARIFF_3 = r'^\d-\d:1\.8\.3.+?\r\n'
+ELECTRICITY_USED_TARIFF_4 = r'^\d-\d:1\.8\.4.+?\r\n'
 ELECTRICITY_DELIVERED_TARIFF_1 = r'^\d-\d:2\.8\.1.+?\r\n'
 ELECTRICITY_DELIVERED_TARIFF_2 = r'^\d-\d:2\.8\.2.+?\r\n'
+ELECTRICITY_DELIVERED_TARIFF_3 = r'^\d-\d:2\.8\.3.+?\r\n'
+ELECTRICITY_DELIVERED_TARIFF_4 = r'^\d-\d:2\.8\.4.+?\r\n'
 CURRENT_REACTIVE_IMPORTED = r'^\d-\d:3\.7\.0.+?\r\n'
 ELECTRICITY_REACTIVE_IMPORTED_TOTAL = r'^\d-\d:3\.8\.0.+?\r\n'
 ELECTRICITY_REACTIVE_IMPORTED_TARIFF_1 = r'^\d-\d:3\.8\.1.+?\r\n'
@@ -39,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'
@@ -84,8 +91,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
@@ -124,10 +129,6 @@ Q3D_EQUIPMENT_STATE = r'^\d-\d:96\.5\.5.+?\r\n'  # Device state (hexadecimal)
 Q3D_EQUIPMENT_SERIALNUMBER = r'^\d-\d:96\.1\.255.+?\r\n'  # Device Serialnumber
 
 # EON Hungary
-EON_HU_ELECTRICITY_USED_TARIFF_3 = r'^\d-\d:1\.8\.3.+?\r\n'
-EON_HU_ELECTRICITY_USED_TARIFF_4 = r'^\d-\d:1\.8\.4.+?\r\n'
-EON_HU_ELECTRICITY_DELIVERED_TARIFF_3 = r'^\d-\d:2\.8\.3.+?\r\n'
-EON_HU_ELECTRICITY_DELIVERED_TARIFF_4 = r'^\d-\d:2\.8\.4.+?\r\n'
 EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q1 = r'^\d-\d:5\.8\.0.+?\r\n'
 EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q2 = r'^\d-\d:6\.8\.0.+?\r\n'
 EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q3 = r'^\d-\d:7\.8\.0.+?\r\n'
@@ -142,7 +143,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_L1 = r'^\d-\d:31\.4\.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'
-EON_HU_LAST_MONTH_DATA = r'^\d-\d:98\.1\.0.+?\r\n'

dsmr_parser/objects.py

@@ -5,8 +5,6 @@ import json
 
 import pytz
 
-from dsmr_parser import obis_name_mapping
-
 
 class Telegram(dict):
     """
@@ -27,22 +25,21 @@ class Telegram(dict):
         self._mbus_devices = []
         super().__init__(*args, **kwargs)
 
-    def add(self, obis_reference, dsmr_object):
+    def add(self, obis_reference, dsmr_object, obis_name):
         # Update name mapping used to get value by attribute. Example: telegram.P1_MESSAGE_HEADER
-        obis_name = obis_name_mapping.EN[obis_reference]
         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)
+            self._add_mbus(obis_reference, dsmr_object, obis_name)
 
         # Fill dict which is only used for backwards compatibility
         if obis_reference not in self:
             self[obis_reference] = dsmr_object
 
-    def _add_mbus(self, obis_reference, dsmr_object):
+    def _add_mbus(self, obis_reference, dsmr_object, obis_name):
         """
         The given DsmrObject is assumed to be Mbus related and will be grouped into a MbusDevice.
         Grouping is done by the DsmrObject channel ID.
@@ -55,7 +52,7 @@ class Telegram(dict):
             mbus_device = MbusDevice(channel_id=channel_id)
             self._mbus_devices.append(mbus_device)
 
-        mbus_device.add(obis_reference, dsmr_object)
+        mbus_device.add(obis_reference, dsmr_object, obis_name)
 
         if not hasattr(self, 'MBUS_DEVICES'):
             setattr(self, 'MBUS_DEVICES', self._mbus_devices)
@@ -143,22 +140,25 @@ class MBusObject(DSMRObject):
             return self.values[1]['unit']
 
     def __str__(self):
+        timestamp = self.datetime
+        if isinstance(timestamp, datetime.datetime):
+            timestamp = timestamp.astimezone().astimezone(pytz.utc).isoformat()
         output = "{}\t[{}] at {}".format(
             str(self.value),
             str(self.unit),
-            str(self.datetime.astimezone().astimezone(pytz.utc).isoformat())
+            str(timestamp)
         )
         return output
 
     def to_json(self):
         timestamp = self.datetime
-        if isinstance(self.datetime, datetime.datetime):
-            timestamp = self.datetime.astimezone().astimezone(pytz.utc).isoformat()
+        if isinstance(timestamp, datetime.datetime):
+            timestamp = timestamp.astimezone().astimezone(pytz.utc).isoformat()
         value = self.value
-        if isinstance(self.value, datetime.datetime):
-            value = self.value.astimezone().astimezone(pytz.utc).isoformat()
-        if isinstance(self.value, Decimal):
-            value = float(self.value)
+        if isinstance(value, datetime.datetime):
+            value = value.astimezone().astimezone(pytz.utc).isoformat()
+        if isinstance(value, Decimal):
+            value = float(value)
         output = {
             'datetime': timestamp,
             'value': value,
@@ -186,23 +186,33 @@ class MBusObjectPeak(DSMRObject):
         return self.values[2]['unit']
 
     def __str__(self):
+        timestamp = self.datetime
+        if isinstance(timestamp, datetime.datetime):
+            timestamp = timestamp.astimezone().astimezone(pytz.utc).isoformat()
+        timestamp_occurred = self.occurred
+        if isinstance(timestamp_occurred, datetime.datetime):
+            timestamp_occurred = timestamp_occurred.astimezone().astimezone(pytz.utc).isoformat()
+        value = self.value
+        if isinstance(value, datetime.datetime):
+            value = value.astimezone().astimezone(pytz.utc).isoformat()
+        if isinstance(value, Decimal):
+            value = float(value)
         output = "{}\t[{}] at {} occurred {}"\
-            .format(str(self.value), str(self.unit), str(self.datetime.astimezone().astimezone(pytz.utc).isoformat()),
-                    str(self.occurred.astimezone().astimezone(pytz.utc).isoformat()))
+            .format(str(value), str(self.unit), str(timestamp), str(timestamp_occurred))
         return output
 
     def to_json(self):
         timestamp = self.datetime
-        if isinstance(self.datetime, datetime.datetime):
-            timestamp = self.datetime.astimezone().astimezone(pytz.utc).isoformat()
+        if isinstance(timestamp, datetime.datetime):
+            timestamp = timestamp.astimezone().astimezone(pytz.utc).isoformat()
         timestamp_occurred = self.occurred
-        if isinstance(self.occurred, datetime.datetime):
-            timestamp_occurred = self.occurred.astimezone().astimezone(pytz.utc).isoformat()
+        if isinstance(timestamp_occurred, datetime.datetime):
+            timestamp_occurred = timestamp_occurred.astimezone().astimezone(pytz.utc).isoformat()
         value = self.value
-        if isinstance(self.value, datetime.datetime):
-            value = self.value.astimezone().astimezone(pytz.utc).isoformat()
-        if isinstance(self.value, Decimal):
-            value = float(self.value)
+        if isinstance(value, datetime.datetime):
+            value = value.astimezone().astimezone(pytz.utc).isoformat()
+        if isinstance(value, Decimal):
+            value = float(value)
         output = {
             'datetime': timestamp,
             'occurred': timestamp_occurred,
@@ -331,10 +341,9 @@ class MbusDevice:
         self.channel_id = channel_id
         self._item_names = []
 
-    def add(self, obis_reference, dsmr_object):
+    def add(self, obis_reference, dsmr_object, obis_name):
         # Update name mapping used to get value by attribute. Example: telegram.P1_MESSAGE_HEADER
         # Also keep track of the added names internally
-        obis_name = obis_name_mapping.EN[obis_reference]
         setattr(self, obis_name, dsmr_object)
         self._item_names.append(obis_name)
 

dsmr_parser/parsers.py

@@ -29,8 +29,8 @@ class TelegramParser(object):
         self.telegram_specification = telegram_specification
         # Regexes are compiled once to improve performance
         self.telegram_specification_regexes = {
-            signature: re.compile(signature, re.DOTALL | re.MULTILINE)
-            for signature in self.telegram_specification['objects'].keys()
+            object["obis_reference"]: re.compile(object["obis_reference"], re.DOTALL | re.MULTILINE)
+            for object in self.telegram_specification['objects']
         }
 
     def parse(self, telegram_data, encryption_key="", authentication_key="", throw_ex=False):  # noqa: C901
@@ -84,25 +84,31 @@ class TelegramParser(object):
 
         telegram = Telegram()
 
-        for signature, parser in self.telegram_specification['objects'].items():
-            pattern = self.telegram_specification_regexes[signature]
+        for object in self.telegram_specification['objects']:
+            pattern = self.telegram_specification_regexes[object["obis_reference"]]
             matches = pattern.findall(telegram_data)
 
             # Some signatures are optional and may not be present,
             # so only parse lines that match
             for match in matches:
                 try:
-                    dsmr_object = parser.parse(match)
+                    dsmr_object = object["value_parser"].parse(match)
                 except ParseError:
-                    logger.error("ignore line with signature {}, because parsing failed.".format(signature),
-                                 exc_info=True)
+                    logger.error(
+                        "ignore line with signature {}, because parsing failed.".format(object["obis_reference"]),
+                        exc_info=True
+                    )
                     if throw_ex:
                         raise
                 except Exception as err:
                     logger.error("Unexpected {}: {}".format(type(err), err))
                     raise
                 else:
-                    telegram.add(obis_reference=signature, dsmr_object=dsmr_object)
+                    telegram.add(
+                        obis_reference=object["obis_reference"],
+                        dsmr_object=dsmr_object,
+                        obis_name=object["value_name"]
+                    )
 
         return telegram
 

setup.py

@@ -7,7 +7,7 @@ setup(
     author_email='mail@nldr.net',
     license='MIT',
     url='https://github.com/ndokter/dsmr_parser',
-    version='1.2.4',
+    version='1.3.1',
     packages=find_packages(exclude=('test', 'test.*')),
     install_requires=[
         'pyserial>=3,<4',

test/example_telegrams.py

@@ -175,7 +175,7 @@ TELEGRAM_V5_TWO_MBUS = (
 )
 
 TELEGRAM_FLUVIUS_V171 = (
-    '/FLU5\253769484_A\r\n'
+    '/FLU5\\253769484_A\r\n'
     '\r\n'
     '0-0:96.1.4(50217)\r\n'
     '0-0:96.1.1(3153414733313031303231363035)\r\n'
@@ -213,7 +213,49 @@ TELEGRAM_FLUVIUS_V171 = (
     '0-2:24.1.0(007)\r\n'
     '0-2:96.1.1(3853414731323334353637383930)\r\n'
     '0-2:24.2.1(200512134558S)(00872.234*m3)\r\n'
-    '!911C\r\n'
+    '!3AD7\r\n'
+)
+
+TELEGRAM_FLUVIUS_V171_ALT = (
+    '/FLU5\\253769484_A\r\n'
+    '\r\n'
+    '0-0:96.1.4(50217)\r\n'
+    '0-0:96.1.1(3153414733313030373231333236)\r\n'
+    '0-0:1.0.0(231102121548W)\r\n'
+    '1-0:1.8.1(000301.548*kWh)\r\n'
+    '1-0:1.8.2(000270.014*kWh)\r\n'
+    '1-0:2.8.1(000000.005*kWh)\r\n'
+    '1-0:2.8.2(000000.000*kWh)\r\n'
+    '0-0:96.14.0(0001)\r\n'
+    '1-0:1.4.0(00.052*kW)\r\n'
+    '1-0:1.6.0(231102114500W)(03.064*kW)\r\n'
+    '0-0:98.1.0(4)(1-0:1.6.0)(1-0:1.6.0)(230801000000S)(632525252525W)(00.000*kW)(230901000000S)(230831181500S)(01.862*kW)(231001000000S)(230910183000S)(04.229*kW)(231101000000W)(231016130000S)(04.927*kW)\r\n'
+    '1-0:1.7.0(00.338*kW)\r\n'
+    '1-0:2.7.0(00.000*kW)\r\n'
+    '1-0:21.7.0(00.047*kW)\r\n'
+    '1-0:41.7.0(00.179*kW)\r\n'
+    '1-0:61.7.0(00.111*kW)\r\n'
+    '1-0:22.7.0(00.000*kW)\r\n'
+    '1-0:42.7.0(00.000*kW)\r\n'
+    '1-0:62.7.0(00.000*kW)\r\n'
+    '1-0:32.7.0(232.9*V)\r\n'
+    '1-0:52.7.0(228.1*V)\r\n'
+    '1-0:72.7.0(228.1*V)\r\n'
+    '1-0:31.7.0(000.27*A)\r\n'
+    '1-0:51.7.0(000.88*A)\r\n'
+    '1-0:71.7.0(000.52*A)\r\n'
+    '0-0:96.3.10(1)\r\n'
+    '0-0:17.0.0(999.9*kW)\r\n'
+    '1-0:31.4.0(999*A)\r\n'
+    '0-0:96.13.0()\r\n'
+    '0-1:24.1.0(003)\r\n'
+    '0-1:96.1.1(37464C4F32313233303838303237)\r\n'
+    '0-1:24.4.0(1)\r\n'
+    '0-1:24.2.3(231102121002W)(00092.287*m3)\r\n'
+    '0-2:24.1.0(007)\r\n'
+    '0-2:96.1.1(3853455430303030393631313733)\r\n'
+    '0-2:24.2.1(231102121532W)(00008.579*m3)\r\n'
+    '!C4B0\r\n'
 )
 
 # EasyMeter via COM-1 Ethernet Gateway
@@ -362,4 +404,4 @@ TELEGRAM_V5_EON_HU = (
     '0-0:98.1.0(230701000000S)(000040.777*kWh)(000008.950*kWh)(000031.827*kWh)(000142.250*kWh)(000111.164*kWh)(000031.086*kWh)(000000.030*kvarh)(000073.988*kvarh)(000000.205*kvarh)(000000.048*kvarh)(000039.199*kvarh)(000035.020*kvarh)(000183.027*kWh)(03.564*kW)(02.156*kW)(03.564*kW)(04.104*kW)(04.104*kW)(03.400*kW)\r\n'
     '0-0:96.13.0()\r\n'
     '!99DA\r\n'
-)
+)

test/objects/test_mbusdevice.py

@@ -12,19 +12,31 @@ class MbusDeviceTest(unittest.TestCase):
     def setUp(self):
         v5_objects = telegram_specifications.V5['objects']
 
-        device_type_parser = v5_objects[obis_references.DEVICE_TYPE]
+        device_type_parser = [
+            object["value_parser"]
+            for object in v5_objects
+            if object["obis_reference"] == obis_references.DEVICE_TYPE
+        ][0]
         device_type = device_type_parser.parse('0-2:24.1.0(003)\r\n')
 
-        equipment_parser = v5_objects[obis_references.EQUIPMENT_IDENTIFIER_GAS]
+        equipment_parser = [
+            object["value_parser"]
+            for object in v5_objects
+            if object["obis_reference"] == obis_references.EQUIPMENT_IDENTIFIER_GAS
+        ][0]
         equipment = equipment_parser.parse('0-2:96.1.0(4730303339303031393336393930363139)\r\n')
 
-        gas_reading_parser = v5_objects[obis_references.HOURLY_GAS_METER_READING]
+        gas_reading_parser = [
+            object["value_parser"]
+            for object in v5_objects
+            if object["obis_reference"] == obis_references.HOURLY_GAS_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)
-        mbus_device.add(obis_references.EQUIPMENT_IDENTIFIER_GAS, equipment)
-        mbus_device.add(obis_references.HOURLY_GAS_METER_READING, gas_reading)
+        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")
 
         self.mbus_device = mbus_device
 

test/objects/test_telegram.py

@@ -4,7 +4,7 @@ import datetime
 import pytz
 
 from dsmr_parser import telegram_specifications, obis_references
-from dsmr_parser import obis_name_mapping
+
 from dsmr_parser.objects import CosemObject
 from dsmr_parser.objects import MBusObject
 from dsmr_parser.objects import ProfileGenericObject
@@ -314,8 +314,8 @@ class TelegramTest(unittest.TestCase):
         self.item_names_tested.append(testitem_name)
 
         # check if all items in telegram V4 specification are covered
-        V4_name_list = [obis_name_mapping.EN[signature] for signature, parser in
-                        telegram_specifications.V4['objects'].items()]
+        V4_name_list = [object["value_name"] for object in
+                        telegram_specifications.V4['objects']]
         V4_name_set = set(V4_name_list)
         item_names_tested_set = set(self.item_names_tested)
 
@@ -329,7 +329,7 @@ class TelegramTest(unittest.TestCase):
             break
 
         # Verify that the iterator works for at least one value
-        self.assertEqual(obis_name, obis_name_mapping.EN[obis_references.P1_MESSAGE_HEADER])
+        self.assertEqual(obis_name, "P1_MESSAGE_HEADER")
         self.assertEqual(dsmr_object.value, '50')
 
     def test_mbus_devices(self):

test/test_parse_fluvius.py

@@ -1,6 +1,7 @@
 from decimal import Decimal
 
 import datetime
+import json
 import unittest
 
 import pytz
@@ -9,7 +10,7 @@ from dsmr_parser import telegram_specifications
 from dsmr_parser.exceptions import InvalidChecksumError, ParseError
 from dsmr_parser.objects import CosemObject, MBusObject, MBusObjectPeak
 from dsmr_parser.parsers import TelegramParser
-from test.example_telegrams import TELEGRAM_FLUVIUS_V171
+from test.example_telegrams import TELEGRAM_FLUVIUS_V171, TELEGRAM_FLUVIUS_V171_ALT
 
 
 class TelegramParserFluviusTest(unittest.TestCase):
@@ -210,17 +211,17 @@ 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)
@@ -286,6 +287,133 @@ class TelegramParserFluviusTest(unittest.TestCase):
 
     def test_checksum_missing(self):
         # Remove the checksum value causing a ParseError.
-        corrupted_telegram = TELEGRAM_FLUVIUS_V171.replace('!911C\r\n', '')
+        corrupted_telegram = TELEGRAM_FLUVIUS_V171.replace('!3AD7\r\n', '')
         with self.assertRaises(ParseError):
             TelegramParser.validate_checksum(corrupted_telegram)
+
+    def test_to_json(self):
+        parser = TelegramParser(telegram_specifications.BELGIUM_FLUVIUS)
+        telegram = parser.parse(TELEGRAM_FLUVIUS_V171_ALT)
+        json_data = json.loads(telegram.to_json())
+
+        self.assertEqual(
+            json_data,
+            {'BELGIUM_VERSION_INFORMATION': {'value': '50217', 'unit': None},
+             'BELGIUM_EQUIPMENT_IDENTIFIER': {'value': '3153414733313030373231333236', 'unit': None},
+             'P1_MESSAGE_TIMESTAMP': {'value': '2023-11-02T11:15:48+00:00', 'unit': None},
+             'ELECTRICITY_USED_TARIFF_1': {'value': 301.548, 'unit': 'kWh'},
+             'ELECTRICITY_USED_TARIFF_2': {'value': 270.014, 'unit': 'kWh'},
+             'ELECTRICITY_DELIVERED_TARIFF_1': {'value': 0.005, 'unit': 'kWh'},
+             'ELECTRICITY_DELIVERED_TARIFF_2': {'value': 0.0, 'unit': 'kWh'},
+             'ELECTRICITY_ACTIVE_TARIFF': {'value': '0001', 'unit': None},
+             'BELGIUM_CURRENT_AVERAGE_DEMAND': {'value': 0.052, 'unit': 'kW'},
+             'BELGIUM_MAXIMUM_DEMAND_MONTH': {'datetime': '2023-11-02T10:45:00+00:00',
+                                              'value': 3.064, 'unit': 'kW'},
+             'BELGIUM_MAXIMUM_DEMAND_13_MONTHS': [{'datetime': '2023-07-31T22:00:00+00:00',
+                                                   'occurred': None, 'value': 0.0, 'unit': 'kW'},
+                                                  {'datetime': '2023-08-31T22:00:00+00:00',
+                                                   'occurred': '2023-08-31T16:15:00+00:00',
+                                                   'value': 1.862, 'unit': 'kW'},
+                                                  {'datetime': '2023-09-30T22:00:00+00:00',
+                                                   'occurred': '2023-09-10T16:30:00+00:00',
+                                                   'value': 4.229, 'unit': 'kW'},
+                                                  {'datetime': '2023-10-31T23:00:00+00:00',
+                                                   'occurred': '2023-10-16T11:00:00+00:00',
+                                                   'value': 4.927, 'unit': 'kW'}],
+             'CURRENT_ELECTRICITY_USAGE': {'value': 0.338, 'unit': 'kW'},
+             'CURRENT_ELECTRICITY_DELIVERY': {'value': 0.0, 'unit': 'kW'},
+             'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE': {'value': 0.047, 'unit': 'kW'},
+             'INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE': {'value': 0.179, 'unit': 'kW'},
+             'INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE': {'value': 0.111, 'unit': 'kW'},
+             'INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE': {'value': 0.0, 'unit': 'kW'},
+             'INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE': {'value': 0.0, 'unit': 'kW'},
+             'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE': {'value': 0.0, 'unit': 'kW'},
+             'INSTANTANEOUS_VOLTAGE_L1': {'value': 232.9, 'unit': 'V'},
+             'INSTANTANEOUS_VOLTAGE_L2': {'value': 228.1, 'unit': 'V'},
+             'INSTANTANEOUS_VOLTAGE_L3': {'value': 228.1, 'unit': 'V'},
+             'INSTANTANEOUS_CURRENT_L1': {'value': 0.27, 'unit': 'A'},
+             'INSTANTANEOUS_CURRENT_L2': {'value': 0.88, 'unit': 'A'},
+             'INSTANTANEOUS_CURRENT_L3': {'value': 0.52, 'unit': 'A'},
+             'ACTUAL_SWITCH_POSITION': {'value': 1, 'unit': None},
+             'ACTUAL_TRESHOLD_ELECTRICITY': {'value': 999.9, 'unit': 'kW'},
+             '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',
+                                                                      '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'},
+                               'CHANNEL_ID': 1},
+                              {'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'},
+                               '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'}}
+        )
+
+    def test_to_str(self):
+        parser = TelegramParser(telegram_specifications.BELGIUM_FLUVIUS)
+        telegram = parser.parse(TELEGRAM_FLUVIUS_V171_ALT)
+
+        self.assertEqual(
+            str(telegram),
+            (
+                'BELGIUM_VERSION_INFORMATION: 	 50217	[None]\n'
+                'BELGIUM_EQUIPMENT_IDENTIFIER: 	 3153414733313030373231333236	[None]\n'
+                'P1_MESSAGE_TIMESTAMP: 	 2023-11-02T11:15:48+00:00	[None]\n'
+                'ELECTRICITY_USED_TARIFF_1: 	 301.548	[kWh]\n'
+                'ELECTRICITY_USED_TARIFF_2: 	 270.014	[kWh]\n'
+                'ELECTRICITY_DELIVERED_TARIFF_1: 	 0.005	[kWh]\n'
+                'ELECTRICITY_DELIVERED_TARIFF_2: 	 0.000	[kWh]\n'
+                'ELECTRICITY_ACTIVE_TARIFF: 	 0001	[None]\n'
+                'BELGIUM_CURRENT_AVERAGE_DEMAND: 	 0.052	[kW]\n'
+                'BELGIUM_MAXIMUM_DEMAND_MONTH: 	 3.064	[kW] at 2023-11-02T10:45:00+00:00\n'
+                '0.0	[kW] at 2023-07-31T22:00:00+00:00 occurred None'
+                '1.862	[kW] at 2023-08-31T22:00:00+00:00 occurred 2023-08-31T16:15:00+00:00'
+                '4.229	[kW] at 2023-09-30T22:00:00+00:00 occurred 2023-09-10T16:30:00+00:00'
+                '4.927	[kW] at 2023-10-31T23:00:00+00:00 occurred 2023-10-16T11:00:00+00:00'
+                'CURRENT_ELECTRICITY_USAGE: 	 0.338	[kW]\n'
+                'CURRENT_ELECTRICITY_DELIVERY: 	 0.000	[kW]\n'
+                'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: 	 0.047	[kW]\n'
+                'INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE: 	 0.179	[kW]\n'
+                'INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE: 	 0.111	[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'
+                'INSTANTANEOUS_VOLTAGE_L1: 	 232.9	[V]\n'
+                'INSTANTANEOUS_VOLTAGE_L2: 	 228.1	[V]\n'
+                'INSTANTANEOUS_VOLTAGE_L3: 	 228.1	[V]\n'
+                'INSTANTANEOUS_CURRENT_L1: 	 0.27	[A]\n'
+                'INSTANTANEOUS_CURRENT_L2: 	 0.88	[A]\n'
+                'INSTANTANEOUS_CURRENT_L3: 	 0.52	[A]\n'
+                'ACTUAL_SWITCH_POSITION: 	 1	[None]\n'
+                'ACTUAL_TRESHOLD_ELECTRICITY: 	 999.9	[kW]\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 (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'
+            )
+        )

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

test/test_parse_v5_eon_hungary.py

@@ -7,7 +7,7 @@ import pytz
 
 from dsmr_parser import telegram_specifications
 from dsmr_parser.exceptions import InvalidChecksumError, ParseError
-from dsmr_parser.objects import CosemObject, MBusObject
+from dsmr_parser.objects import CosemObject
 from dsmr_parser.parsers import TelegramParser
 from test.example_telegrams import TELEGRAM_V5_EON_HU
 
@@ -29,17 +29,17 @@ class TelegramParserV5EONHUTest(unittest.TestCase):
         assert telegram.P1_MESSAGE_TIMESTAMP.value == \
             pytz.timezone("Europe/Budapest").localize(datetime.datetime(2023, 7, 24, 15, 7, 30))
 
-        # LUXEMBOURG_EQUIPMENT_IDENTIFIER (0-0:42.0.0)
-        assert isinstance(telegram.LUXEMBOURG_EQUIPMENT_IDENTIFIER, CosemObject)
-        assert telegram.LUXEMBOURG_EQUIPMENT_IDENTIFIER.unit is None
-        assert isinstance(telegram.LUXEMBOURG_EQUIPMENT_IDENTIFIER.value, str)
-        assert telegram.LUXEMBOURG_EQUIPMENT_IDENTIFIER.value == '53414733303832323030303032313630'
+        # EON_HU_COSEM_LOGICAL_DEVICE_NAME (0-0:42.0.0)
+        assert isinstance(telegram.COSEM_LOGICAL_DEVICE_NAME, CosemObject)
+        assert telegram.COSEM_LOGICAL_DEVICE_NAME.unit is None
+        assert isinstance(telegram.COSEM_LOGICAL_DEVICE_NAME.value, str)
+        assert telegram.COSEM_LOGICAL_DEVICE_NAME.value == '53414733303832323030303032313630'
 
-        # EQUIPMENT_IDENTIFIER_GAS (0-0:96.1.0)
-        assert isinstance(telegram.EQUIPMENT_IDENTIFIER_GAS, CosemObject)
-        assert telegram.EQUIPMENT_IDENTIFIER_GAS.unit is None
-        assert isinstance(telegram.EQUIPMENT_IDENTIFIER_GAS.value, str)
-        assert telegram.EQUIPMENT_IDENTIFIER_GAS.value == '383930303832323030303032313630'
+        # EON_HU_EQUIPMENT_SERIAL_NUMBER (0-0:96.1.0)
+        assert isinstance(telegram.EQUIPMENT_SERIAL_NUMBER, CosemObject)
+        assert telegram.EQUIPMENT_SERIAL_NUMBER.unit is None
+        assert isinstance(telegram.EQUIPMENT_SERIAL_NUMBER.value, str)
+        assert telegram.EQUIPMENT_SERIAL_NUMBER.value == '383930303832323030303032313630'
 
         # ELECTRICITY_ACTIVE_TARIFF (0-0:96.14.0)
         assert isinstance(telegram.ELECTRICITY_ACTIVE_TARIFF, CosemObject)
@@ -53,11 +53,11 @@ class TelegramParserV5EONHUTest(unittest.TestCase):
         assert isinstance(telegram.ACTUAL_SWITCH_POSITION.value, str)
         assert telegram.ACTUAL_SWITCH_POSITION.value == '1'
 
-        # BELGIUM_MAX_POWER_PER_PHASE (ACTUAL_TRESHOLD_ELECTRICITY) (0-0:17.0.0)
-        assert isinstance(telegram.BELGIUM_MAX_POWER_PER_PHASE, CosemObject)
-        assert telegram.BELGIUM_MAX_POWER_PER_PHASE.unit == 'kW'
-        assert isinstance(telegram.BELGIUM_MAX_POWER_PER_PHASE.value, Decimal)
-        assert telegram.BELGIUM_MAX_POWER_PER_PHASE.value == Decimal('90.000')
+        # ACTUAL_TRESHOLD_ELECTRICITY (0-0:17.0.0)
+        assert isinstance(telegram.ACTUAL_TRESHOLD_ELECTRICITY, CosemObject)
+        assert telegram.ACTUAL_TRESHOLD_ELECTRICITY.unit == 'kW'
+        assert isinstance(telegram.ACTUAL_TRESHOLD_ELECTRICITY.value, Decimal)
+        assert telegram.ACTUAL_TRESHOLD_ELECTRICITY.value == Decimal('90.000')
 
         # ELECTRICITY_IMPORTED_TOTAL (1-0:1.8.0)
         assert isinstance(telegram.ELECTRICITY_IMPORTED_TOTAL, CosemObject)
@@ -78,16 +78,16 @@ class TelegramParserV5EONHUTest(unittest.TestCase):
         assert telegram.ELECTRICITY_USED_TARIFF_2.value == Decimal('000125.921')
 
         # EON_HU_ELECTRICITY_USED_TARIFF_3 (1-0:1.8.3)
-        assert isinstance(telegram.EON_HU_ELECTRICITY_USED_TARIFF_3, CosemObject)
-        assert telegram.EON_HU_ELECTRICITY_USED_TARIFF_3.unit == 'kWh'
-        assert isinstance(telegram.EON_HU_ELECTRICITY_USED_TARIFF_3.value, Decimal)
-        assert telegram.EON_HU_ELECTRICITY_USED_TARIFF_3.value == Decimal('000000.000')
+        assert isinstance(telegram.ELECTRICITY_USED_TARIFF_3, CosemObject)
+        assert telegram.ELECTRICITY_USED_TARIFF_3.unit == 'kWh'
+        assert isinstance(telegram.ELECTRICITY_USED_TARIFF_3.value, Decimal)
+        assert telegram.ELECTRICITY_USED_TARIFF_3.value == Decimal('000000.000')
 
         # EON_HU_ELECTRICITY_USED_TARIFF_4 (1-0:1.8.4)
-        assert isinstance(telegram.EON_HU_ELECTRICITY_USED_TARIFF_4, CosemObject)
-        assert telegram.EON_HU_ELECTRICITY_USED_TARIFF_4.unit == 'kWh'
-        assert isinstance(telegram.EON_HU_ELECTRICITY_USED_TARIFF_4.value, Decimal)
-        assert telegram.EON_HU_ELECTRICITY_USED_TARIFF_4.value == Decimal('000000.000')
+        assert isinstance(telegram.ELECTRICITY_USED_TARIFF_4, CosemObject)
+        assert telegram.ELECTRICITY_USED_TARIFF_4.unit == 'kWh'
+        assert isinstance(telegram.ELECTRICITY_USED_TARIFF_4.value, Decimal)
+        assert telegram.ELECTRICITY_USED_TARIFF_4.value == Decimal('000000.000')
 
         # ELECTRICITY_EXPORTED_TOTAL (1-0:2.8.0)
         assert isinstance(telegram.ELECTRICITY_EXPORTED_TOTAL, CosemObject)
@@ -108,16 +108,16 @@ class TelegramParserV5EONHUTest(unittest.TestCase):
         assert telegram.ELECTRICITY_DELIVERED_TARIFF_2.value == Decimal('000225.348')
 
         # EON_HU_ELECTRICITY_DELIVERED_TARIFF_3 (1-0:2.8.3)
-        assert isinstance(telegram.EON_HU_ELECTRICITY_DELIVERED_TARIFF_3, CosemObject)
-        assert telegram.EON_HU_ELECTRICITY_DELIVERED_TARIFF_3.unit == 'kWh'
-        assert isinstance(telegram.EON_HU_ELECTRICITY_DELIVERED_TARIFF_3.value, Decimal)
-        assert telegram.EON_HU_ELECTRICITY_DELIVERED_TARIFF_3.value == Decimal('000000.000')
+        assert isinstance(telegram.ELECTRICITY_DELIVERED_TARIFF_3, CosemObject)
+        assert telegram.ELECTRICITY_DELIVERED_TARIFF_3.unit == 'kWh'
+        assert isinstance(telegram.ELECTRICITY_DELIVERED_TARIFF_3.value, Decimal)
+        assert telegram.ELECTRICITY_DELIVERED_TARIFF_3.value == Decimal('000000.000')
 
         # EON_HU_ELECTRICITY_DELIVERED_TARIFF_4 (1-0:2.8.4)
-        assert isinstance(telegram.EON_HU_ELECTRICITY_DELIVERED_TARIFF_4, CosemObject)
-        assert telegram.EON_HU_ELECTRICITY_DELIVERED_TARIFF_4.unit == 'kWh'
-        assert isinstance(telegram.EON_HU_ELECTRICITY_DELIVERED_TARIFF_4.value, Decimal)
-        assert telegram.EON_HU_ELECTRICITY_DELIVERED_TARIFF_4.value == Decimal('000000.000')
+        assert isinstance(telegram.ELECTRICITY_DELIVERED_TARIFF_4, CosemObject)
+        assert telegram.ELECTRICITY_DELIVERED_TARIFF_4.unit == 'kWh'
+        assert isinstance(telegram.ELECTRICITY_DELIVERED_TARIFF_4.value, Decimal)
+        assert telegram.ELECTRICITY_DELIVERED_TARIFF_4.value == Decimal('000000.000')
 
         # ELECTRICITY_REACTIVE_IMPORTED_TOTAL (1-0:3.8.0)
         assert isinstance(telegram.ELECTRICITY_REACTIVE_IMPORTED_TOTAL, CosemObject)
@@ -132,34 +132,34 @@ class TelegramParserV5EONHUTest(unittest.TestCase):
         assert telegram.ELECTRICITY_REACTIVE_EXPORTED_TOTAL.value == Decimal('000303.131')
 
         # EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q1 (1-0:5.8.0)
-        assert isinstance(telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q1, CosemObject)
-        assert telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q1.unit == 'kvarh'
-        assert isinstance(telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q1.value, Decimal)
-        assert telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q1.value == Decimal('000000.668')
+        assert isinstance(telegram.ELECTRICITY_REACTIVE_TOTAL_Q1, CosemObject)
+        assert telegram.ELECTRICITY_REACTIVE_TOTAL_Q1.unit == 'kvarh'
+        assert isinstance(telegram.ELECTRICITY_REACTIVE_TOTAL_Q1.value, Decimal)
+        assert telegram.ELECTRICITY_REACTIVE_TOTAL_Q1.value == Decimal('000000.668')
 
         # EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q2 (1-0:6.8.0)
-        assert isinstance(telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q2, CosemObject)
-        assert telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q2.unit == 'kvarh'
-        assert isinstance(telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q2.value, Decimal)
-        assert telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q2.value == Decimal('000000.071')
+        assert isinstance(telegram.ELECTRICITY_REACTIVE_TOTAL_Q2, CosemObject)
+        assert telegram.ELECTRICITY_REACTIVE_TOTAL_Q2.unit == 'kvarh'
+        assert isinstance(telegram.ELECTRICITY_REACTIVE_TOTAL_Q2.value, Decimal)
+        assert telegram.ELECTRICITY_REACTIVE_TOTAL_Q2.value == Decimal('000000.071')
 
         # EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q3 (1-0:7.8.0)
-        assert isinstance(telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q3, CosemObject)
-        assert telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q3.unit == 'kvarh'
-        assert isinstance(telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q3.value, Decimal)
-        assert telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q3.value == Decimal('000160.487')
+        assert isinstance(telegram.ELECTRICITY_REACTIVE_TOTAL_Q3, CosemObject)
+        assert telegram.ELECTRICITY_REACTIVE_TOTAL_Q3.unit == 'kvarh'
+        assert isinstance(telegram.ELECTRICITY_REACTIVE_TOTAL_Q3.value, Decimal)
+        assert telegram.ELECTRICITY_REACTIVE_TOTAL_Q3.value == Decimal('000160.487')
 
         # EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q4 (1-0:8.8.0)
-        assert isinstance(telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q4, CosemObject)
-        assert telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q4.unit == 'kvarh'
-        assert isinstance(telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q4.value, Decimal)
-        assert telegram.EON_HU_ELECTRICITY_REACTIVE_TOTAL_Q4.value == Decimal('000143.346')
+        assert isinstance(telegram.ELECTRICITY_REACTIVE_TOTAL_Q4, CosemObject)
+        assert telegram.ELECTRICITY_REACTIVE_TOTAL_Q4.unit == 'kvarh'
+        assert isinstance(telegram.ELECTRICITY_REACTIVE_TOTAL_Q4.value, Decimal)
+        assert telegram.ELECTRICITY_REACTIVE_TOTAL_Q4.value == Decimal('000143.346')
 
         # EON_HU_ELECTRICITY_COMBINED (1-0:15.8.0)
-        assert isinstance(telegram.EON_HU_ELECTRICITY_COMBINED, CosemObject)
-        assert telegram.EON_HU_ELECTRICITY_COMBINED.unit == 'kWh'
-        assert isinstance(telegram.EON_HU_ELECTRICITY_COMBINED.value, Decimal)
-        assert telegram.EON_HU_ELECTRICITY_COMBINED.value == Decimal('000800.817')
+        assert isinstance(telegram.ELECTRICITY_COMBINED, CosemObject)
+        assert telegram.ELECTRICITY_COMBINED.unit == 'kWh'
+        assert isinstance(telegram.ELECTRICITY_COMBINED.value, Decimal)
+        assert telegram.ELECTRICITY_COMBINED.value == Decimal('000800.817')
 
         # INSTANTANEOUS_VOLTAGE_L2 (1-0:32.7.0)
         assert isinstance(telegram.INSTANTANEOUS_VOLTAGE_L1, CosemObject)
@@ -198,34 +198,34 @@ class TelegramParserV5EONHUTest(unittest.TestCase):
         assert telegram.INSTANTANEOUS_CURRENT_L3.value == Decimal('003')
 
         # EON_HU_INSTANTANEOUS_POWER_FACTOR_TOTAL (1-0:13.7.0)
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_TOTAL, CosemObject)
-        assert telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_TOTAL.unit is None
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_TOTAL.value, Decimal)
-        assert telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_TOTAL.value == Decimal('4.556')
+        assert isinstance(telegram.INSTANTANEOUS_POWER_FACTOR_TOTAL, CosemObject)
+        assert telegram.INSTANTANEOUS_POWER_FACTOR_TOTAL.unit is None
+        assert isinstance(telegram.INSTANTANEOUS_POWER_FACTOR_TOTAL.value, Decimal)
+        assert telegram.INSTANTANEOUS_POWER_FACTOR_TOTAL.value == Decimal('4.556')
 
         # EON_HU_INSTANTANEOUS_POWER_FACTOR_L1 (1-0:33.7.0)
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L1, CosemObject)
-        assert telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L1.unit is None
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L1.value, Decimal)
-        assert telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L1.value == Decimal('4.591')
+        assert isinstance(telegram.INSTANTANEOUS_POWER_FACTOR_L1, CosemObject)
+        assert telegram.INSTANTANEOUS_POWER_FACTOR_L1.unit is None
+        assert isinstance(telegram.INSTANTANEOUS_POWER_FACTOR_L1.value, Decimal)
+        assert telegram.INSTANTANEOUS_POWER_FACTOR_L1.value == Decimal('4.591')
 
         # EON_HU_INSTANTANEOUS_POWER_FACTOR_L2 (1-0:53.7.0)
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L2, CosemObject)
-        assert telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L2.unit is None
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L2.value, Decimal)
-        assert telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L2.value == Decimal('4.542')
+        assert isinstance(telegram.INSTANTANEOUS_POWER_FACTOR_L2, CosemObject)
+        assert telegram.INSTANTANEOUS_POWER_FACTOR_L2.unit is None
+        assert isinstance(telegram.INSTANTANEOUS_POWER_FACTOR_L2.value, Decimal)
+        assert telegram.INSTANTANEOUS_POWER_FACTOR_L2.value == Decimal('4.542')
 
         # EON_HU_INSTANTANEOUS_POWER_FACTOR_L3 (1-0:73.7.0)
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L3, CosemObject)
-        assert telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L3.unit is None
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L3.value, Decimal)
-        assert telegram.EON_HU_INSTANTANEOUS_POWER_FACTOR_L3.value == Decimal('4.552')
+        assert isinstance(telegram.INSTANTANEOUS_POWER_FACTOR_L3, CosemObject)
+        assert telegram.INSTANTANEOUS_POWER_FACTOR_L3.unit is None
+        assert isinstance(telegram.INSTANTANEOUS_POWER_FACTOR_L3.value, Decimal)
+        assert telegram.INSTANTANEOUS_POWER_FACTOR_L3.value == Decimal('4.552')
 
         # EON_HU_FREQUENCY (1-0:14.7.0)
-        assert isinstance(telegram.EON_HU_FREQUENCY, CosemObject)
-        assert telegram.EON_HU_FREQUENCY.unit == "Hz"
-        assert isinstance(telegram.EON_HU_FREQUENCY.value, Decimal)
-        assert telegram.EON_HU_FREQUENCY.value == Decimal('50.00')
+        assert isinstance(telegram.FREQUENCY, CosemObject)
+        assert telegram.FREQUENCY.unit == "Hz"
+        assert isinstance(telegram.FREQUENCY.value, Decimal)
+        assert telegram.FREQUENCY.value == Decimal('50.00')
 
         # CURRENT_ELECTRICITY_USAGE (1-0:1.7.0)
         assert isinstance(telegram.CURRENT_ELECTRICITY_USAGE, CosemObject)
@@ -240,46 +240,46 @@ class TelegramParserV5EONHUTest(unittest.TestCase):
         assert telegram.CURRENT_ELECTRICITY_DELIVERY.value == Decimal('02.601')
 
         # EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q1 (1-0:5.7.0)
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q1, CosemObject)
-        assert telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q1.unit == 'kvar'
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q1.value, Decimal)
-        assert telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q1.value == Decimal('00.000')
+        assert isinstance(telegram.INSTANTANEOUS_REACTIVE_POWER_Q1, CosemObject)
+        assert telegram.INSTANTANEOUS_REACTIVE_POWER_Q1.unit == 'kvar'
+        assert isinstance(telegram.INSTANTANEOUS_REACTIVE_POWER_Q1.value, Decimal)
+        assert telegram.INSTANTANEOUS_REACTIVE_POWER_Q1.value == Decimal('00.000')
 
         # EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q2 (1-0:6.7.0)
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q2, CosemObject)
-        assert telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q2.unit == 'kvar'
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q2.value, Decimal)
-        assert telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q2.value == Decimal('00.000')
+        assert isinstance(telegram.INSTANTANEOUS_REACTIVE_POWER_Q2, CosemObject)
+        assert telegram.INSTANTANEOUS_REACTIVE_POWER_Q2.unit == 'kvar'
+        assert isinstance(telegram.INSTANTANEOUS_REACTIVE_POWER_Q2.value, Decimal)
+        assert telegram.INSTANTANEOUS_REACTIVE_POWER_Q2.value == Decimal('00.000')
 
         # EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q3 (1-0:7.7.0)
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q3, CosemObject)
-        assert telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q3.unit == 'kvar'
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q3.value, Decimal)
-        assert telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q3.value == Decimal('00.504')
+        assert isinstance(telegram.INSTANTANEOUS_REACTIVE_POWER_Q3, CosemObject)
+        assert telegram.INSTANTANEOUS_REACTIVE_POWER_Q3.unit == 'kvar'
+        assert isinstance(telegram.INSTANTANEOUS_REACTIVE_POWER_Q3.value, Decimal)
+        assert telegram.INSTANTANEOUS_REACTIVE_POWER_Q3.value == Decimal('00.504')
 
         # EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q4 (1-0:8.7.0)
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q4, CosemObject)
-        assert telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q4.unit == 'kvar'
-        assert isinstance(telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q4.value, Decimal)
-        assert telegram.EON_HU_INSTANTANEOUS_REACTIVE_POWER_Q4.value == Decimal('00.000')
+        assert isinstance(telegram.INSTANTANEOUS_REACTIVE_POWER_Q4, CosemObject)
+        assert telegram.INSTANTANEOUS_REACTIVE_POWER_Q4.unit == 'kvar'
+        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.EON_HU_MAX_POWER_ON_L1, CosemObject)
-        assert telegram.EON_HU_MAX_POWER_ON_L1.unit == 'A'
-        assert isinstance(telegram.EON_HU_MAX_POWER_ON_L1.value, Decimal)
-        assert telegram.EON_HU_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.EON_HU_MAX_POWER_ON_L2, CosemObject)
-        assert telegram.EON_HU_MAX_POWER_ON_L2.unit == 'A'
-        assert isinstance(telegram.EON_HU_MAX_POWER_ON_L2.value, Decimal)
-        assert telegram.EON_HU_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.EON_HU_MAX_POWER_ON_L3, CosemObject)
-        assert telegram.EON_HU_MAX_POWER_ON_L3.unit == 'A'
-        assert isinstance(telegram.EON_HU_MAX_POWER_ON_L3.value, Decimal)
-        assert telegram.EON_HU_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