add workflow test for python 3.12

.github/workflows/tests.yml

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

CHANGELOG.rst

@@ -1,39 +1,19 @@
 Change Log
 ----------
 
-**1.5.0** (2024-08-25)
-- Allow the telegram specification to optionally be autodetected (`PR #87 <https://github.com/ndokter/dsmr_parser/pull/87>`_ by `clonerswords <https://github.com/clonerswords>`_)
-
-**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)
@@ -170,7 +150,7 @@ Remove deprecated asyncio coroutine decorator (`PR #76 <https://github.com/ndokt
 **0.12** (2018-09-23)
 
 - Add serial settings for DSMR v5.0 (`PR #31 <https://github.com/ndokter/dsmr_parser/pull/31>`_).
-- Lux-creos-obis-1.8.0 (`PR #32 <https://github.com/ndokter/dsmr_parser/pull/32>`_).
+- Lux-creos-obis-1.8.0 (`PR #32 <https://github.com/ndokter/dsmr_parser/pull/32>`_). 
 
 **0.11** (2017-09-18)
 

README.rst

@@ -293,36 +293,6 @@ 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.info(str(e))
+                        logger.warning(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_fast import create_serial_connection
+from serial_asyncio 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.info(str(e))
+            self.log.warning(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_fast import create_serial_connection
+from serial_asyncio 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_fast
+import serial_asyncio
 
 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.info(str(e))
+                        logger.warning(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_fast.open_serial_connection(**self.serial_settings)
+        conn = serial_asyncio.open_serial_connection(**self.serial_settings)
         reader, _ = await conn
 
         while True:
@@ -107,7 +107,7 @@ class AsyncSerialReader(SerialReader):
         """
 
         # create Serial StreamReader
-        conn = serial_asyncio_fast.open_serial_connection(**self.serial_settings)
+        conn = serial_asyncio.open_serial_connection(**self.serial_settings)
         reader, _ = await conn
 
         while True:

dsmr_parser/clients/socket_.py

@@ -31,15 +31,11 @@ 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:
-                try:
-                    buffer += socket_handle.recv(self.BUFFER_SIZE)
-                except socket.timeout:
-                    logger.error("Socket timeout occurred, exiting")
-                    break
+                buffer += socket_handle.recv(self.BUFFER_SIZE)
 
                 lines = buffer.splitlines(keepends=True)
 
@@ -58,7 +54,7 @@ class SocketReader(object):
                     try:
                         yield self.telegram_parser.parse(telegram)
                     except InvalidChecksumError as e:
-                        logger.info(str(e))
+                        logger.warning(str(e))
                     except ParseError as e:
                         logger.error('Failed to parse telegram: %s', e)
 

dsmr_parser/exceptions.py

@@ -4,7 +4,3 @@ class ParseError(Exception):
 
 class InvalidChecksumError(ParseError):
     pass
-
-
-class TelegramSpecificationMatchError(ParseError):
-    pass

dsmr_parser/obis_references.py

@@ -69,25 +69,8 @@ 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,
@@ -109,6 +92,36 @@ 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'
 
+# 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
 
 Q3D_EQUIPMENT_IDENTIFIER = r'^\d-\d:0\.0\.0.+?\r\n'  # Logical device name

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

@@ -9,7 +9,7 @@ from dlms_cosem.connection import XDlmsApduFactory
 from dlms_cosem.protocol.xdlms import GeneralGlobalCipher
 
 from dsmr_parser.objects import MBusObject, MBusObjectPeak, CosemObject, ProfileGenericObject, Telegram
-from dsmr_parser.exceptions import ParseError, InvalidChecksumError, TelegramSpecificationMatchError
+from dsmr_parser.exceptions import ParseError, InvalidChecksumError
 from dsmr_parser.value_types import timestamp
 
 logger = logging.getLogger(__name__)
@@ -18,17 +18,20 @@ logger = logging.getLogger(__name__)
 class TelegramParser(object):
     crc16_tab = []
 
-    def __init__(self, telegram_specification=None, apply_checksum_validation=True):
+    def __init__(self, telegram_specification, apply_checksum_validation=True):
         """
-        :param telegram_specification: determines how the telegram is parsed.
-            Will attempt to autodetect if omitted.
+        :param telegram_specification: determines how the telegram is parsed
         :param apply_checksum_validation: validate checksum if applicable for
             telegram DSMR version (v4 and up).
         :type telegram_specification: dict
         """
         self.apply_checksum_validation = apply_checksum_validation
         self.telegram_specification = telegram_specification
-        self._telegram_specification_regex = None
+        # Regexes are compiled once to improve performance
+        self.telegram_specification_regexes = {
+            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
         """
@@ -43,15 +46,6 @@ class TelegramParser(object):
         :raises ParseError:
         :raises InvalidChecksumError:
         """
-        if not self.telegram_specification:
-            self.telegram_specification = \
-                match_telegram_specification(telegram_data)
-        if not self._telegram_specification_regex:
-            # Regexes are compiled once to improve performance
-            self._telegram_specification_regexes = {
-                object["obis_reference"]: re.compile(object["obis_reference"], re.DOTALL | re.MULTILINE)
-                for object in self.telegram_specification['objects']
-            }
 
         if "general_global_cipher" in self.telegram_specification:
             if self.telegram_specification["general_global_cipher"]:
@@ -91,7 +85,7 @@ class TelegramParser(object):
         telegram = Telegram()
 
         for object in self.telegram_specification['objects']:
-            pattern = self._telegram_specification_regexes[object["obis_reference"]]
+            pattern = self.telegram_specification_regexes[object["obis_reference"]]
             matches = pattern.findall(telegram_data)
 
             # Some signatures are optional and may not be present,
@@ -179,37 +173,6 @@ class TelegramParser(object):
         return crcValue
 
 
-def match_telegram_specification(telegram_data):
-    """
-    Find telegram specification that matches the telegram data by trying all
-    specifications.
-
-    Could be further optimized to check the actual 0.2.8 OBIS reference which
-    is available for DSMR version 4 and up.
-
-    :param str telegram_data: full telegram from start ('/') to checksum
-            ('!ABCD') including line endings in between the telegram's lines
-    :return: telegram specification
-    :rtype: dict
-    """
-    # Prevent circular import
-    from dsmr_parser import telegram_specifications
-
-    for specification in telegram_specifications.ALL:
-        try:
-            TelegramParser(specification).parse(telegram_data)
-        except ParseError:
-            pass
-        else:
-            return specification
-
-    raise TelegramSpecificationMatchError(
-        'Could automatically match telegram specification. Make sure the data'
-        'is not corrupt. Alternatively manually specify one.'
-    )
-
-
-
 class DSMRObjectParser(object):
     """
     Parses an object (can also be see as a 'line') from a telegram.
@@ -372,7 +335,7 @@ class ProfileGenericParser(DSMRObjectParser):
     """
 
     def __init__(self, buffer_types, head_parsers, parsers_for_unidentified):
-        self.value_formats = head_parsers.copy()
+        self.value_formats = head_parsers
         self.buffer_types = buffer_types
         self.parsers_for_unidentified = parsers_for_unidentified
 

dsmr_parser/telegram_specifications.py

@@ -430,6 +430,11 @@ 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)),
@@ -461,31 +466,23 @@ V5 = {
             'value_name': 'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE'
         },
         {
-            'obis_reference': obis.MBUS_DEVICE_TYPE,
-            'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'MBUS_DEVICE_TYPE'
-        },
-        {
-            'obis_reference': obis.MBUS_EQUIPMENT_IDENTIFIER,
+            'obis_reference': obis.EQUIPMENT_IDENTIFIER_GAS,
             'value_parser': CosemParser(ValueParser(str)),
-            'value_name': 'MBUS_EQUIPMENT_IDENTIFIER'
+            'value_name': 'EQUIPMENT_IDENTIFIER_GAS'
         },
         {
-            '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(
+            'obis_reference': obis.HOURLY_GAS_METER_READING,
+            'value_parser':  MBusParser(
                 ValueParser(timestamp),
                 ValueParser(Decimal)
             ),
-            'value_name': 'MBUS_METER_READING'
+            'value_name': 'HOURLY_GAS_METER_READING'
         },
     ]
 }
 
+ALL = (V2_2, V3, V4, V5)
+
 BELGIUM_FLUVIUS = {
     'checksum_support': True,
     'objects': [
@@ -627,6 +624,11 @@ BELGIUM_FLUVIUS = {
             'value_parser': CosemParser(ValueParser(Decimal)),
             'value_name': 'ACTUAL_TRESHOLD_ELECTRICITY'
         },
+        {
+            'obis_reference': obis.ACTUAL_TRESHOLD_ELECTRICITY,
+            'value_parser': CosemParser(ValueParser(Decimal)),
+            'value_name': 'ACTUAL_TRESHOLD_ELECTRICITY'
+        },
         {
             'obis_reference': obis.FUSE_THRESHOLD_L1,
             'value_parser': CosemParser(ValueParser(Decimal)),
@@ -638,27 +640,128 @@ BELGIUM_FLUVIUS = {
             'value_name': 'TEXT_MESSAGE'
         },
         {
-            'obis_reference': obis.MBUS_DEVICE_TYPE,
+            'obis_reference': obis.BELGIUM_MBUS1_DEVICE_TYPE,
             'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'MBUS_DEVICE_TYPE'
+            'value_name': 'BELGIUM_MBUS1_DEVICE_TYPE'
         },
         {
-            'obis_reference': obis.MBUS_EQUIPMENT_IDENTIFIER,
+            'obis_reference': obis.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER,
             'value_parser': CosemParser(ValueParser(str)),
-            'value_name': 'MBUS_EQUIPMENT_IDENTIFIER'
+            'value_name': 'BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER'
         },
         {
-            'obis_reference': obis.MBUS_VALVE_POSITION,
+            'obis_reference': obis.BELGIUM_MBUS1_VALVE_POSITION,
             'value_parser': CosemParser(ValueParser(int)),
-            'value_name': 'MBUS_VALVE_POSITION'
+            'value_name': 'BELGIUM_MBUS1_VALVE_POSITION'
         },
         {
-            'obis_reference': obis.MBUS_METER_READING,
+            'obis_reference': obis.BELGIUM_MBUS1_METER_READING1,
             'value_parser': MBusParser(
                 ValueParser(timestamp),
                 ValueParser(Decimal)
             ),
-            'value_name': 'MBUS_METER_READING'
+            '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'
         },
     ]
 }
@@ -859,11 +962,6 @@ 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)),
@@ -1366,17 +1464,3 @@ EON_HUNGARY = {
         }
     ]
 }
-
-ALL = (
-    V2_2,
-    V3,
-    V4,
-    V5,
-    BELGIUM_FLUVIUS,
-    LUXEMBOURG_SMARTY,
-    SWEDEN,
-    SAGEMCOM_T210_D_R,
-    AUSTRIA_ENERGIENETZE_STEIERMARK,
-    ISKRA_IE,
-    EON_HUNGARY
-)

dsmr_parser/value_types.py

@@ -2,10 +2,6 @@ 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:
@@ -24,6 +20,8 @@ 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.5.0',
+    version='1.3.1',
     packages=find_packages(exclude=('test', 'test.*')),
     install_requires=[
         'pyserial>=3,<4',
-        'pyserial-asyncio-fast>=0.11',
+        'pyserial-asyncio<1',
         'pytz',
         'Tailer==0.4.1',
         'dlms_cosem==21.3.2'

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.MBUS_DEVICE_TYPE
+            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 = [
             object["value_parser"]
             for object in v5_objects
-            if object["obis_reference"] == obis_references.MBUS_EQUIPMENT_IDENTIFIER
+            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 = [
             object["value_parser"]
             for object in v5_objects
-            if object["obis_reference"] == obis_references.MBUS_METER_READING
+            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=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")
+        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")
 
         self.mbus_device = mbus_device
 
     def test_attributes(self):
-        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.DEVICE_TYPE.value, 3)
+        self.assertEqual(self.mbus_device.DEVICE_TYPE.unit, None)
 
-        self.assertEqual(self.mbus_device.MBUS_EQUIPMENT_IDENTIFIER.value,
+        self.assertEqual(self.mbus_device.EQUIPMENT_IDENTIFIER_GAS.value,
                          '4730303339303031393336393930363139')
-        self.assertEqual(self.mbus_device.MBUS_EQUIPMENT_IDENTIFIER.unit, None)
+        self.assertEqual(self.mbus_device.EQUIPMENT_IDENTIFIER_GAS.unit, None)
 
-        self.assertEqual(self.mbus_device.MBUS_METER_READING.value, Decimal('246.138'))
-        self.assertEqual(self.mbus_device.MBUS_METER_READING.unit, 'm3')
+        self.assertEqual(self.mbus_device.HOURLY_GAS_METER_READING.value, Decimal('246.138'))
+        self.assertEqual(self.mbus_device.HOURLY_GAS_METER_READING.unit, 'm3')
 
     def test_to_json(self):
         self.assertEqual(
             json.loads(self.mbus_device.to_json()),
             {
-                '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'}}
+                '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'}}
         )
 
     def test_str(self):
         self.assertEqual(
             str(self.mbus_device),
             (
-                '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'
+                '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'
             )
         )

test/objects/test_telegram.py

@@ -216,6 +216,14 @@ 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',
@@ -264,15 +272,7 @@ class TelegramTest(unittest.TestCase):
                                   value_type=Decimal,
                                   value_val=Decimal('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)
+        # EQUIPMENT_IDENTIFIER_GAS (0-x: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.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'))
+        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'))
 
         mbus_device_2 = mbus_devices[1]
-        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'))
+        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'))
 
     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.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'))
+        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'))
 
         mbus_device_2 = telegram.get_mbus_device_by_channel(2)
-        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'))
+        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'))
 
     def test_without_mbus_devices(self):
         parser = TelegramParser(telegram_specifications.V5, apply_checksum_validation=False)
@@ -375,12 +375,11 @@ 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},
@@ -388,6 +387,10 @@ 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},
@@ -402,16 +405,15 @@ 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,
-                               '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}},
+                               '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}},
                               {'CHANNEL_ID': 2,
-                               'MBUS_DEVICE_TYPE': {'unit': None, 'value': 3},
-                               'MBUS_EQUIPMENT_IDENTIFIER': {'unit': None,
-                                                             'value': None}}],
+                               'DEVICE_TYPE': {'unit': None, 'value': 3},
+                               'EQUIPMENT_IDENTIFIER_GAS': {'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': [],
@@ -431,8 +433,6 @@ class TelegramTest(unittest.TestCase):
         parser = TelegramParser(telegram_specifications.V5)
         telegram = parser.parse(TELEGRAM_V5)
 
-        self.maxDiff = None
-
         self.assertEqual(
             str(telegram),
             (
@@ -463,19 +463,22 @@ 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'
-                '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'
+                'EQUIPMENT_IDENTIFIER_GAS: 	 None	[None]\n'
+                'HOURLY_GAS_METER_READING: 	 0.107	[m3] at 2017-01-02T15:10:05+00:00\n'
             )
         )
 

test/test_match_telegram_specification.py

@@ -1,29 +0,0 @@
-import unittest
-
-from dsmr_parser.exceptions import TelegramSpecificationMatchError
-from dsmr_parser.parsers import match_telegram_specification
-from dsmr_parser import telegram_specifications
-from test import example_telegrams
-
-
-class MatchTelegramSpecificationTest(unittest.TestCase):
-
-    def test_v2_2(self):
-        assert match_telegram_specification(example_telegrams.TELEGRAM_V2_2) \
-           == telegram_specifications.V2_2
-
-    def test_v3(self):
-        assert match_telegram_specification(example_telegrams.TELEGRAM_V3) \
-           == telegram_specifications.V3
-
-    def test_v4_2(self):
-        assert match_telegram_specification(example_telegrams.TELEGRAM_V4_2) \
-           == telegram_specifications.V4
-
-    def test_v5(self):
-        assert match_telegram_specification(example_telegrams.TELEGRAM_V5) \
-           == telegram_specifications.V5
-
-    def test_malformed_telegram(self):
-        with self.assertRaises(TelegramSpecificationMatchError):
-            match_telegram_specification(example_telegrams.TELEGRAM_V5[:-4])

test/test_parse_fluvius.py

@@ -228,53 +228,47 @@ class TelegramParserFluviusTest(unittest.TestCase):
         assert result.TEXT_MESSAGE.unit is None
         assert result.TEXT_MESSAGE.value is None
 
-        # MBUS DEVICE 1
-        mbus1 = result.get_mbus_device_by_channel(1)
+        # 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_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_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_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_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_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_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_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_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 DEVICE 2
-        mbus2 = result.get_mbus_device_by_channel(2)
+        # 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_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')
+        # 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')
 
     def test_checksum_valid(self):
         # No exception is raised.
@@ -302,8 +296,6 @@ 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},
@@ -346,19 +338,26 @@ class TelegramParserFluviusTest(unittest.TestCase):
              'ACTUAL_TRESHOLD_ELECTRICITY': {'value': 999.9, 'unit': 'kW'},
              'FUSE_THRESHOLD_L1': {'value': 999.0, 'unit': 'A'},
              'TEXT_MESSAGE': {'value': None, 'unit': None},
-             'MBUS_DEVICES': [{'MBUS_DEVICE_TYPE': {'value': 3, 'unit': None},
-                               'MBUS_EQUIPMENT_IDENTIFIER': {'value': '37464C4F32313233303838303237',
+             '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},
-                               'MBUS_VALVE_POSITION': {'value': 1, 'unit': None},
-                               'MBUS_METER_READING': {'datetime': '2023-11-02T11:10:02+00:00',
-                                                                  'value': 92.287, 'unit': 'm3'},
+                               '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},
-                              {'MBUS_DEVICE_TYPE': {'value': 7, 'unit': None},
-                               'MBUS_EQUIPMENT_IDENTIFIER': {'value': '3853455430303030393631313733',
+                              {'BELGIUM_MBUS2_DEVICE_TYPE': {'value': 7, 'unit': None},
+                               'BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER': {'value': '3853455430303030393631313733',
                                                                       'unit': None},
-                               'MBUS_METER_READING': {'datetime': '2023-11-02T11:15:32+00:00',
-                                                                  'value': 8.579, 'unit': 'm3'},
-                               'CHANNEL_ID': 2}]}
+                               '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):
@@ -400,14 +399,21 @@ class TelegramParserFluviusTest(unittest.TestCase):
                 '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'
-                '	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'
+                '	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'
-                '	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'
+                '	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_v2_2.py

@@ -12,15 +12,6 @@ from test.example_telegrams import TELEGRAM_V2_2
 class TelegramParserV2_2Test(unittest.TestCase):
     """ Test parsing of a DSMR v2.2 telegram. """
 
-    def test_telegram_specification_matching(self):
-        parser = TelegramParser()
-        parser.parse(TELEGRAM_V2_2)
-
-        self.assertEqual(
-            parser.telegram_specification,
-            telegram_specifications.V2_2
-        )
-
     def test_parse(self):
         parser = TelegramParser(telegram_specifications.V2_2)
         try:

test/test_parse_v3.py

@@ -12,15 +12,6 @@ from test.example_telegrams import TELEGRAM_V3
 class TelegramParserV3Test(unittest.TestCase):
     """ Test parsing of a DSMR v3 telegram. """
 
-    def test_telegram_specification_matching(self):
-        parser = TelegramParser()
-        parser.parse(TELEGRAM_V3)
-
-        self.assertEqual(
-            parser.telegram_specification,
-            telegram_specifications.V3
-        )
-
     def test_parse(self):
         parser = TelegramParser(telegram_specifications.V3)
         try:

test/test_parse_v4_2.py

@@ -15,15 +15,6 @@ from test.example_telegrams import TELEGRAM_V4_2
 class TelegramParserV4_2Test(unittest.TestCase):
     """ Test parsing of a DSMR v4.2 telegram. """
 
-    def test_telegram_specification_matching(self):
-        parser = TelegramParser()
-        parser.parse(TELEGRAM_V4_2)
-
-        self.assertEqual(
-            parser.telegram_specification,
-            telegram_specifications.V4
-        )
-
     def test_parse(self):
         parser = TelegramParser(telegram_specifications.V4)
         try:

test/test_parse_v5.py

@@ -15,15 +15,6 @@ from test.example_telegrams import TELEGRAM_V5
 class TelegramParserV5Test(unittest.TestCase):
     """ Test parsing of a DSMR v5.x telegram. """
 
-    def test_telegram_specification_matching(self):
-        parser = TelegramParser()
-        parser.parse(TELEGRAM_V5)
-
-        self.assertEqual(
-            parser.telegram_specification,
-            telegram_specifications.V5
-        )
-
     def test_parse(self):
         parser = TelegramParser(telegram_specifications.V5)
         try:
@@ -181,6 +172,12 @@ 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'
@@ -218,27 +215,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_mbus_device_by_channel
+        # use get_mbget_mbus_device_by_channel
         gas_meter_devices = telegram.MBUS_DEVICES
         gas_meter_device = gas_meter_devices[0]
 
-        # 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.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_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'
+        # 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_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')
+        # 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')
 
     def test_checksum_valid(self):
         # No exception is raised.
@@ -273,11 +270,8 @@ class TelegramParserV5Test(unittest.TestCase):
         parser = TelegramParser(telegram_specifications.V5)
         telegram = parser.parse(invalid_date_telegram)
 
-        # 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')
+        # 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')

tox.ini

@@ -14,9 +14,6 @@ commands=
 [pylama:dsmr_parser/clients/__init__.py]
 ignore = W0611
 
-[pylama:dsmr_parser/clients/socket_.py]
-ignore = C901
-
 [pylama:dsmr_parser/parsers.py]
 ignore = W605
 
@@ -27,4 +24,4 @@ ignore = E501
 max_line_length = 120
 
 [pylama:pycodestyle]
-max_line_length = 120
+max_line_length = 120