Merge pull request #54 from lowdef/fix_json_serialization

Fix json serialization

.gitignore

@@ -2,7 +2,13 @@
 *.pyc
 .tox
 .cache
+.venv
 *.egg-info
 /.project
 /.pydevproject
 /.coverage
+build/
+dist/
+venv/
+*.*~
+*~

CHANGELOG.rst

@@ -1,9 +1,60 @@
 Change Log
 ----------
+**0.21** (2020-05-25)
+
+- All objects can produce a json serialization of their state.
+
+**0.20** (2020-05-12)
+
+- All objects can now print their values
+- Add parser + object for generic profile
+
+**0.19** (2020-05-03)
+
+- Add following missing elements to telegram specification v4:
+    - SHORT_POWER_FAILURE_COUNT,
+    - INSTANTANEOUS_CURRENT_L1,
+    - INSTANTANEOUS_CURRENT_L2,
+    - INSTANTANEOUS_CURRENT_L3
+- Add missing tests + fix small test bugs
+- Complete telegram object v4 parse test
+
+**0.18** (2020-01-28)
+
+- PyCRC replacement (`pull request #48 <https://github.com/ndokter/dsmr_parser/pull/48>`_).
+
+**0.17** (2019-12-21)
+
+- Add a true telegram object (`pull request #40 <https://github.com/ndokter/dsmr_parser/pull/40>`_).
+
+**0.16** (2019-12-21)
+
+- Add support for Belgian and Smarty meters (`pull request #44 <https://github.com/ndokter/dsmr_parser/pull/44>`_).
+
+**0.15** (2019-12-12)
+
+- Fixed asyncio loop issue (`pull request #43 <https://github.com/ndokter/dsmr_parser/pull/43>`_).
+
+**0.14** (2019-10-08)
+
+- Changed serial reading to reduce CPU usage (`pull request #37 <https://github.com/ndokter/dsmr_parser/pull/37>`_).
+
+**0.13** (2019-03-04)
+
+- Fix DSMR v5.0 serial settings which were not used (`pull request #33 <https://github.com/ndokter/dsmr_parser/pull/33>`_).
+
+**0.12** (2018-09-23)
+
+- Add serial settings for DSMR v5.0 (`pull request #31 <https://github.com/ndokter/dsmr_parser/pull/31>`_).
+- Lux-creos-obis-1.8.0 (`pull request #32 <https://github.com/ndokter/dsmr_parser/pull/32>`_). 
+
+**0.11** (2017-09-18)
+
+- NULL value fix in checksum (`pull request #26 <https://github.com/ndokter/dsmr_parser/pull/26>`_)
 
 **0.10** (2017-06-05)
 
-- bugix: don't force full telegram signatures (`pull request #25 <https://github.com/ndokter/dsmr_parser/pull/25>`_)
+- bugfix: don't force full telegram signatures (`pull request #25 <https://github.com/ndokter/dsmr_parser/pull/25>`_)
 - removed unused code for automatic telegram detection as this needs reworking after the fix mentioned above
 - InvalidChecksumError's are logged as warning instead of error
 

README.rst

@@ -85,8 +85,8 @@ into a dictionary.
      telegram = parser.parse(telegram_str)
      print(telegram)  # see 'Telegram object' docs below
 
-Telegram object
----------------
+Telegram dictionary
+-------------------
 
 A dictionary of which the key indicates the field type. These regex values
 correspond to one of dsmr_parser.obis_reference constants.
@@ -138,6 +138,115 @@ Example to get some of the values:
     # See dsmr_reader.obis_references for all readable telegram values.
     # Note that the avilable values differ per DSMR version.
 
+Telegram as an Object
+---------------------
+An object version of the telegram is available as well.
+
+
+.. code-block:: python
+
+    # DSMR v4.2 p1 using dsmr_parser and telegram objects
+
+    from dsmr_parser import telegram_specifications
+    from dsmr_parser.clients import SerialReader, SERIAL_SETTINGS_V5
+    from dsmr_parser.objects import CosemObject, MBusObject, Telegram
+    from dsmr_parser.parsers import TelegramParser
+    import os
+
+    serial_reader = SerialReader(
+        device='/dev/ttyUSB0',
+        serial_settings=SERIAL_SETTINGS_V5,
+        telegram_specification=telegram_specifications.V4
+    )
+
+    # telegram = next(serial_reader.read_as_object())
+    # print(telegram)
+
+    for telegram in serial_reader.read_as_object():
+        os.system('clear')
+        print(telegram)
+
+Example of output of print of the telegram object:
+
+.. code-block:: console
+
+    P1_MESSAGE_HEADER: 	 42 	[None]
+    P1_MESSAGE_TIMESTAMP: 	 2016-11-13 19:57:57+00:00 	[None]
+    EQUIPMENT_IDENTIFIER: 	 3960221976967177082151037881335713 	[None]
+    ELECTRICITY_USED_TARIFF_1: 	 1581.123 	[kWh]
+    ELECTRICITY_USED_TARIFF_2: 	 1435.706 	[kWh]
+    ELECTRICITY_DELIVERED_TARIFF_1: 	 0.000 	[kWh]
+    ELECTRICITY_DELIVERED_TARIFF_2: 	 0.000 	[kWh]
+    ELECTRICITY_ACTIVE_TARIFF: 	 0002 	[None]
+    CURRENT_ELECTRICITY_USAGE: 	 2.027 	[kW]
+    CURRENT_ELECTRICITY_DELIVERY: 	 0.000 	[kW]
+    LONG_POWER_FAILURE_COUNT: 	 7 	[None]
+    VOLTAGE_SAG_L1_COUNT: 	 0 	[None]
+    VOLTAGE_SAG_L2_COUNT: 	 0 	[None]
+    VOLTAGE_SAG_L3_COUNT: 	 0 	[None]
+    VOLTAGE_SWELL_L1_COUNT: 	 0 	[None]
+    VOLTAGE_SWELL_L2_COUNT: 	 0 	[None]
+    VOLTAGE_SWELL_L3_COUNT: 	 0 	[None]
+    TEXT_MESSAGE_CODE: 	 None 	[None]
+    TEXT_MESSAGE: 	 None 	[None]
+    DEVICE_TYPE: 	 3 	[None]
+    INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: 	 0.170 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE: 	 1.247 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE: 	 0.209 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE: 	 0.000 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE: 	 0.000 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE: 	 0.000 	[kW]
+    EQUIPMENT_IDENTIFIER_GAS: 	 4819243993373755377509728609491464 	[None]
+    HOURLY_GAS_METER_READING: 	 981.443 	[m3]
+
+Accessing the telegrams information as  attributes directly:
+
+.. code-block:: python
+
+    telegram
+    Out[3]: <dsmr_parser.objects.Telegram at 0x7f5e995d9898>
+    telegram.CURRENT_ELECTRICITY_USAGE
+    Out[4]: <dsmr_parser.objects.CosemObject at 0x7f5e98ae5ac8>
+    telegram.CURRENT_ELECTRICITY_USAGE.value
+    Out[5]: Decimal('2.027')
+    telegram.CURRENT_ELECTRICITY_USAGE.unit
+    Out[6]: 'kW'
+
+The telegram object has an iterator, can be used to find all the information elements in the current telegram:
+
+.. code-block:: python
+
+    [attr for attr, value in telegram]
+    Out[11]:
+    ['P1_MESSAGE_HEADER',
+     'P1_MESSAGE_TIMESTAMP',
+     'EQUIPMENT_IDENTIFIER',
+     'ELECTRICITY_USED_TARIFF_1',
+     'ELECTRICITY_USED_TARIFF_2',
+     'ELECTRICITY_DELIVERED_TARIFF_1',
+     'ELECTRICITY_DELIVERED_TARIFF_2',
+     'ELECTRICITY_ACTIVE_TARIFF',
+     'CURRENT_ELECTRICITY_USAGE',
+     'CURRENT_ELECTRICITY_DELIVERY',
+     'LONG_POWER_FAILURE_COUNT',
+     'VOLTAGE_SAG_L1_COUNT',
+     'VOLTAGE_SAG_L2_COUNT',
+     'VOLTAGE_SAG_L3_COUNT',
+     'VOLTAGE_SWELL_L1_COUNT',
+     'VOLTAGE_SWELL_L2_COUNT',
+     'VOLTAGE_SWELL_L3_COUNT',
+     'TEXT_MESSAGE_CODE',
+     'TEXT_MESSAGE',
+     'DEVICE_TYPE',
+     'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE',
+     'EQUIPMENT_IDENTIFIER_GAS',
+     'HOURLY_GAS_METER_READING']
+
 
 Installation
 ------------

dsmr_parser/clients/__init__.py

@@ -1,5 +1,5 @@
 from dsmr_parser.clients.settings import SERIAL_SETTINGS_V2_2, \
-    SERIAL_SETTINGS_V4
+    SERIAL_SETTINGS_V4, SERIAL_SETTINGS_V5
 from dsmr_parser.clients.serial_ import SerialReader, AsyncSerialReader
 from dsmr_parser.clients.protocol import create_dsmr_protocol, \
     create_dsmr_reader, create_tcp_dsmr_reader

dsmr_parser/clients/filereader.py

@@ -0,0 +1,171 @@
+import logging
+import fileinput
+import tailer
+
+from dsmr_parser.clients.telegram_buffer import TelegramBuffer
+from dsmr_parser.exceptions import ParseError, InvalidChecksumError
+from dsmr_parser.objects import Telegram
+from dsmr_parser.parsers import TelegramParser
+
+logger = logging.getLogger(__name__)
+
+
+class FileReader(object):
+    """
+     Filereader to read and parse raw telegram strings from a file and instantiate Telegram objects
+     for each read telegram.
+     Usage:
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.clients.filereader import FileReader
+
+        if __name__== "__main__":
+
+            infile = '/data/smartmeter/readings.txt'
+
+            file_reader = FileReader(
+                file = infile,
+                telegram_specification = telegram_specifications.V4
+                )
+
+            for telegram in file_reader.read_as_object():
+                print(telegram)
+
+     The file can be created like:
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.clients import SerialReader, SERIAL_SETTINGS_V5
+
+        if __name__== "__main__":
+
+            outfile = '/data/smartmeter/readings.txt'
+
+            serial_reader = SerialReader(
+                device='/dev/ttyUSB0',
+                serial_settings=SERIAL_SETTINGS_V5,
+                telegram_specification=telegram_specifications.V4
+            )
+
+            for telegram in serial_reader.read_as_object():
+                f=open(outfile,"ab+")
+                f.write(telegram._telegram_data.encode())
+                f.close()
+     """
+
+    def __init__(self, file, telegram_specification):
+        self._file = file
+        self.telegram_parser = TelegramParser(telegram_specification)
+        self.telegram_buffer = TelegramBuffer()
+        self.telegram_specification = telegram_specification
+
+    def read_as_object(self):
+        """
+        Read complete DSMR telegram's from a file and return a Telegram object.
+        :rtype: generator
+        """
+        with open(self._file, "rb") as file_handle:
+            while True:
+                data = file_handle.readline()
+                str = data.decode()
+                self.telegram_buffer.append(str)
+
+                for telegram in self.telegram_buffer.get_all():
+                    try:
+                        yield Telegram(telegram, self.telegram_parser, self.telegram_specification)
+                    except InvalidChecksumError as e:
+                        logger.warning(str(e))
+                    except ParseError as e:
+                        logger.error('Failed to parse telegram: %s', e)
+
+
+class FileInputReader(object):
+    """
+     Filereader to read and parse raw telegram strings from stdin or files specified at the commandline
+     and instantiate Telegram objects for each read telegram.
+     Usage python script "syphon_smartmeter_readings_stdin.py":
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.clients.filereader import FileInputReader
+
+        if __name__== "__main__":
+
+            fileinput_reader = FileReader(
+                file = infile,
+                telegram_specification = telegram_specifications.V4
+                )
+
+            for telegram in fileinput_reader.read_as_object():
+                print(telegram)
+
+    Command line:
+        tail -f /data/smartmeter/readings.txt | python3 syphon_smartmeter_readings_stdin.py
+
+     """
+
+    def __init__(self, telegram_specification):
+        self.telegram_parser = TelegramParser(telegram_specification)
+        self.telegram_buffer = TelegramBuffer()
+        self.telegram_specification = telegram_specification
+
+    def read_as_object(self):
+        """
+        Read complete DSMR telegram's from stdin of filearguments specified on teh command line
+        and return a Telegram object.
+        :rtype: generator
+        """
+        with fileinput.input(mode='rb') as file_handle:
+            while True:
+                data = file_handle.readline()
+                str = data.decode()
+                self.telegram_buffer.append(str)
+
+                for telegram in self.telegram_buffer.get_all():
+                    try:
+                        yield Telegram(telegram, self.telegram_parser, self.telegram_specification)
+                    except InvalidChecksumError as e:
+                        logger.warning(str(e))
+                    except ParseError as e:
+                        logger.error('Failed to parse telegram: %s', e)
+
+
+class FileTailReader(object):
+    """
+      Filereader to read and parse raw telegram strings from the tail of a
+      given file and instantiate Telegram objects for each read telegram.
+      Usage python script "syphon_smartmeter_readings_stdin.py":
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.clients.filereader import FileTailReader
+
+        if __name__== "__main__":
+
+            infile = '/data/smartmeter/readings.txt'
+
+            filetail_reader = FileTailReader(
+                file = infile,
+                telegram_specification = telegram_specifications.V5
+                )
+
+            for telegram in filetail_reader.read_as_object():
+                print(telegram)
+      """
+
+    def __init__(self, file, telegram_specification):
+        self._file = file
+        self.telegram_parser = TelegramParser(telegram_specification)
+        self.telegram_buffer = TelegramBuffer()
+        self.telegram_specification = telegram_specification
+
+    def read_as_object(self):
+        """
+        Read complete DSMR telegram's from a files tail and return a Telegram object.
+        :rtype: generator
+        """
+        with open(self._file, "rb") as file_handle:
+            for data in tailer.follow(file_handle):
+                str = data.decode()
+                self.telegram_buffer.append(str)
+
+                for telegram in self.telegram_buffer.get_all():
+                    try:
+                        yield Telegram(telegram, self.telegram_parser, self.telegram_specification)
+                    except InvalidChecksumError as e:
+                        logger.warning(str(e))
+                    except ParseError as e:
+                        logger.error('Failed to parse telegram: %s', e)

dsmr_parser/clients/protocol.py

@@ -11,7 +11,7 @@ from dsmr_parser.clients.telegram_buffer import TelegramBuffer
 from dsmr_parser.exceptions import ParseError, InvalidChecksumError
 from dsmr_parser.parsers import TelegramParser
 from dsmr_parser.clients.settings import SERIAL_SETTINGS_V2_2, \
-    SERIAL_SETTINGS_V4
+    SERIAL_SETTINGS_V4, SERIAL_SETTINGS_V5
 
 
 def create_dsmr_protocol(dsmr_version, telegram_callback, loop=None):
@@ -25,7 +25,10 @@ def create_dsmr_protocol(dsmr_version, telegram_callback, loop=None):
         serial_settings = SERIAL_SETTINGS_V4
     elif dsmr_version == '5':
         specification = telegram_specifications.V5
-        serial_settings = SERIAL_SETTINGS_V4
+        serial_settings = SERIAL_SETTINGS_V5
+    elif dsmr_version == '5B':
+        specification = telegram_specifications.BELGIUM_FLUVIUS
+        serial_settings = SERIAL_SETTINGS_V5
     else:
         raise NotImplementedError("No telegram parser found for version: %s",
                                   dsmr_version)
@@ -49,8 +52,10 @@ def create_dsmr_reader(port, dsmr_version, telegram_callback, loop=None):
 def create_tcp_dsmr_reader(host, port, dsmr_version,
                            telegram_callback, loop=None):
     """Creates a DSMR asyncio protocol coroutine using TCP connection."""
+    if not loop:
+        loop = asyncio.get_event_loop()
     protocol, _ = create_dsmr_protocol(
-        dsmr_version, telegram_callback, loop=None)
+        dsmr_version, telegram_callback, loop=loop)
     conn = loop.create_connection(protocol, host, port)
     return conn
 

dsmr_parser/clients/serial_.py

@@ -6,6 +6,7 @@ import serial_asyncio
 from dsmr_parser.clients.telegram_buffer import TelegramBuffer
 from dsmr_parser.exceptions import ParseError, InvalidChecksumError
 from dsmr_parser.parsers import TelegramParser
+from dsmr_parser.objects import Telegram
 
 
 logger = logging.getLogger(__name__)
@@ -20,6 +21,7 @@ class SerialReader(object):
 
         self.telegram_parser = TelegramParser(telegram_specification)
         self.telegram_buffer = TelegramBuffer()
+        self.telegram_specification = telegram_specification
 
     def read(self):
         """
@@ -30,7 +32,7 @@ class SerialReader(object):
         """
         with serial.Serial(**self.serial_settings) as serial_handle:
             while True:
-                data = serial_handle.readline()
+                data = serial_handle.read(max(1, min(1024, serial_handle.in_waiting)))
                 self.telegram_buffer.append(data.decode('ascii'))
 
                 for telegram in self.telegram_buffer.get_all():
@@ -41,6 +43,25 @@ class SerialReader(object):
                     except ParseError as e:
                         logger.error('Failed to parse telegram: %s', e)
 
+    def read_as_object(self):
+        """
+        Read complete DSMR telegram's from the serial interface and return a Telegram object.
+
+        :rtype: generator
+        """
+        with serial.Serial(**self.serial_settings) as serial_handle:
+            while True:
+                data = serial_handle.readline()
+                self.telegram_buffer.append(data.decode('ascii'))
+
+                for telegram in self.telegram_buffer.get_all():
+                    try:
+                        yield Telegram(telegram, self.telegram_parser, self.telegram_specification)
+                    except InvalidChecksumError as e:
+                        logger.warning(str(e))
+                    except ParseError as e:
+                        logger.error('Failed to parse telegram: %s', e)
+
 
 class AsyncSerialReader(SerialReader):
     """Serial reader using asyncio pyserial."""

dsmr_parser/clients/settings.py

@@ -20,3 +20,13 @@ SERIAL_SETTINGS_V4 = {
     'rtscts': 0,
     'timeout': 20
 }
+
+SERIAL_SETTINGS_V5 = {
+    'baudrate': 115200,
+    'bytesize': serial.EIGHTBITS,
+    'parity': serial.PARITY_NONE,
+    'stopbits': serial.STOPBITS_ONE,
+    'xonxoff': 0,
+    'rtscts': 0,
+    'timeout': 20
+}

dsmr_parser/clients/telegram_buffer.py

@@ -51,7 +51,7 @@ class TelegramBuffer(object):
         # - The checksum is optional '{0,4}' because not all telegram versions
         # support it.
         return re.findall(
-            r'\/[^\/]+?\![A-F0-9]{0,4}\r\n',
+            r'\/[^\/]+?\![A-F0-9]{0,4}\0?\r\n',
             self._buffer,
             re.DOTALL
         )

dsmr_parser/obis_name_mapping.py

@@ -0,0 +1,54 @@
+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_USED_TARIFF_1: 'ELECTRICITY_USED_TARIFF_1',
+    obis.ELECTRICITY_USED_TARIFF_2: 'ELECTRICITY_USED_TARIFF_2',
+    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.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.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'
+}
+
+REVERSE_EN = dict([(v, k) for k, v in EN.items()])

dsmr_parser/obis_references.py

@@ -8,6 +8,7 @@ objects are introduced.
 """
 P1_MESSAGE_HEADER = r'\d-\d:0\.2\.8.+?\r\n'
 P1_MESSAGE_TIMESTAMP = r'\d-\d:1\.0\.0.+?\r\n'
+ELECTRICITY_IMPORTED_TOTAL = r'\d-\d:1\.8\.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_DELIVERED_TARIFF_1 = r'\d-\d:2\.8\.1.+?\r\n'
@@ -17,6 +18,7 @@ EQUIPMENT_IDENTIFIER = r'\d-\d:96\.1\.1.+?\r\n'
 CURRENT_ELECTRICITY_USAGE = r'\d-\d:1\.7\.0.+?\r\n'
 CURRENT_ELECTRICITY_DELIVERY = r'\d-\d:2\.7\.0.+?\r\n'
 LONG_POWER_FAILURE_COUNT = r'96\.7\.9.+?\r\n'
+SHORT_POWER_FAILURE_COUNT = r'96\.7\.21.+?\r\n'
 POWER_EVENT_FAILURE_LOG = r'99\.97\.0.+?\r\n'
 VOLTAGE_SAG_L1_COUNT = r'\d-\d:32\.32\.0.+?\r\n'
 VOLTAGE_SAG_L2_COUNT = r'\d-\d:52\.32\.0.+?\r\n'
@@ -24,6 +26,12 @@ VOLTAGE_SAG_L3_COUNT = r'\d-\d:72\.32\.0.+?\r\n'
 VOLTAGE_SWELL_L1_COUNT = r'\d-\d:32\.36\.0.+?\r\n'
 VOLTAGE_SWELL_L2_COUNT = r'\d-\d:52\.36\.0.+?\r\n'
 VOLTAGE_SWELL_L3_COUNT = r'\d-\d:72\.36\.0.+?\r\n'
+INSTANTANEOUS_VOLTAGE_L1 = r'\d-\d:32\.7\.0.+?\r\n'
+INSTANTANEOUS_VOLTAGE_L2 = r'\d-\d:52\.7\.0.+?\r\n'
+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'
 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'
@@ -52,3 +60,8 @@ ELECTRICITY_DELIVERED_TARIFF_ALL = (
     ELECTRICITY_DELIVERED_TARIFF_1,
     ELECTRICITY_DELIVERED_TARIFF_2
 )
+
+# Alternate codes for foreign countries.
+BELGIUM_HOURLY_GAS_METER_READING = r'\d-\d:24\.2\.3.+?\r\n'  # Different code, same format.
+LUXEMBOURG_ELECTRICITY_USED_TARIFF_GLOBAL = r'\d-\d:1\.8\.0.+?\r\n'  # Total imported energy register (P+)
+LUXEMBOURG_ELECTRICITY_DELIVERED_TARIFF_GLOBAL = r'\d-\d:2\.8\.0.+?\r\n'  # Total exported energy register (P-)

dsmr_parser/objects.py

@@ -1,3 +1,63 @@
+import dsmr_parser.obis_name_mapping
+import datetime
+import json
+from decimal import Decimal
+
+
+class Telegram(object):
+    """
+    Container for raw and parsed telegram data.
+    Initializing:
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.exceptions import InvalidChecksumError, ParseError
+        from dsmr_parser.objects import CosemObject, MBusObject, Telegram
+        from dsmr_parser.parsers import TelegramParser
+        from test.example_telegrams import TELEGRAM_V4_2
+        parser = TelegramParser(telegram_specifications.V4)
+        telegram = Telegram(TELEGRAM_V4_2, parser, telegram_specifications.V4)
+
+    Attributes can be accessed on a telegram object by addressing by their english name, for example:
+        telegram.ELECTRICITY_USED_TARIFF_1
+
+    All attributes in a telegram can be iterated over, for example:
+        [k for k,v in telegram]
+    yields:
+    ['P1_MESSAGE_HEADER',  'P1_MESSAGE_TIMESTAMP', 'EQUIPMENT_IDENTIFIER', ...]
+    """
+    def __init__(self, telegram_data, telegram_parser, telegram_specification):
+        self._telegram_data = telegram_data
+        self._telegram_specification = telegram_specification
+        self._telegram_parser = telegram_parser
+        self._obis_name_mapping = dsmr_parser.obis_name_mapping.EN
+        self._reverse_obis_name_mapping = dsmr_parser.obis_name_mapping.REVERSE_EN
+        self._dictionary = self._telegram_parser.parse(telegram_data)
+        self._item_names = self._get_item_names()
+
+    def __getattr__(self, name):
+        ''' will only get called for undefined attributes '''
+        obis_reference = self._reverse_obis_name_mapping[name]
+        value = self._dictionary[obis_reference]
+        setattr(self, name, value)
+        return value
+
+    def _get_item_names(self):
+        return [self._obis_name_mapping[k] for k, v in self._dictionary.items()]
+
+    def __iter__(self):
+        for attr in self._item_names:
+            value = getattr(self, attr)
+            yield attr, value
+
+    def __str__(self):
+        output = ""
+        for attr, value in self:
+            output += "{}: \t {}\n".format(attr, str(value))
+        return output
+
+    def to_json(self):
+        return json.dumps(dict([[attr, json.loads(value.to_json())] for attr, value in self]))
+
+
 class DSMRObject(object):
     """
     Represents all data from a single telegram line.
@@ -19,7 +79,7 @@ class MBusObject(DSMRObject):
         # TODO object, but let the parse set them differently? So don't use
         # TODO hardcoded indexes here.
         if len(self.values) != 2:  # v2
-            return self.values[5]['value']
+            return self.values[6]['value']
         else:
             return self.values[1]['value']
 
@@ -29,10 +89,30 @@ class MBusObject(DSMRObject):
         # TODO object, but let the parse set them differently? So don't use
         # TODO hardcoded indexes here.
         if len(self.values) != 2:  # v2
-            return self.values[4]['value']
+            return self.values[5]['value']
         else:
             return self.values[1]['unit']
 
+    def __str__(self):
+        output = "{}\t[{}] at {}".format(str(self.value), str(self.unit), str(self.datetime.astimezone().isoformat()))
+        return output
+
+    def to_json(self):
+        timestamp = self.datetime
+        if isinstance(self.datetime, datetime.datetime):
+            timestamp = self.datetime.astimezone().isoformat()
+        value = self.value
+        if isinstance(self.value, datetime.datetime):
+            value = self.value.astimezone().isoformat()
+        if isinstance(self.value, Decimal):
+            value = float(self.value)
+        output = {
+            'datetime': timestamp,
+            'value': value,
+            'unit': self.unit
+        }
+        return json.dumps(output)
+
 
 class CosemObject(DSMRObject):
 
@@ -44,6 +124,84 @@ class CosemObject(DSMRObject):
     def unit(self):
         return self.values[0]['unit']
 
+    def __str__(self):
+        print_value = self.value
+        if isinstance(self.value, datetime.datetime):
+            print_value = self.value.astimezone().isoformat()
+        output = "{}\t[{}]".format(str(print_value), str(self.unit))
+        return output
 
-class ProfileGeneric(DSMRObject):
-    pass  # TODO implement
+    def to_json(self):
+        json_value = self.value
+        if isinstance(self.value, datetime.datetime):
+            json_value = self.value.astimezone().isoformat()
+        if isinstance(self.value, Decimal):
+            json_value = float(self.value)
+        output = {
+            'value': json_value,
+            'unit': self.unit
+        }
+        return json.dumps(output)
+
+
+class ProfileGenericObject(DSMRObject):
+    """
+    Represents all data in a GenericProfile value.
+    All buffer values are returned as a list of MBusObjects,
+    containing the datetime (timestamp) and the value.
+    """
+
+    def __init__(self, values):
+        super().__init__(values)
+        self._buffer_list = None
+
+    @property
+    def buffer_length(self):
+        return self.values[0]['value']
+
+    @property
+    def buffer_type(self):
+        return self.values[1]['value']
+
+    @property
+    def buffer(self):
+        if self._buffer_list is None:
+            self._buffer_list = []
+            values_offset = 2
+            for i in range(self.buffer_length):
+                offset = values_offset + i*2
+                self._buffer_list.append(MBusObject([self.values[offset], self.values[offset + 1]]))
+        return self._buffer_list
+
+    def __str__(self):
+        output = "\t buffer length: {}\n".format(self.buffer_length)
+        output += "\t buffer type: {}".format(self.buffer_type)
+        for buffer_value in self.buffer:
+            timestamp = buffer_value.datetime
+            if isinstance(timestamp, datetime.datetime):
+                timestamp = str(timestamp.astimezone().isoformat())
+            output += "\n\t event occured at: {}".format(timestamp)
+            output += "\t for: {} [{}]".format(buffer_value.value, buffer_value.unit)
+        return output
+
+    def to_json(self):
+        """
+        :return: A json of all values in the GenericProfileObject , with the following structure
+                 {'buffer_length': n,
+                  'buffer_type': obis_ref,
+                  'buffer': [{'datetime': d1,
+                              'value': v1,
+                              'unit': u1},
+                              ...
+                               {'datetime': dn,
+                              'value': vn,
+                              'unit': un}
+                              ]
+                  }
+        """
+        list = [['buffer_length', self.buffer_length]]
+        list.append(['buffer_type', self.buffer_type])
+        buffer_repr = [json.loads(buffer_item.to_json()) for buffer_item in self.buffer]
+        list.append(['buffer', buffer_repr])
+        output = dict(list)
+        return json.dumps(output)

dsmr_parser/parsers.py

@@ -1,9 +1,9 @@
 import logging
 import re
 
-from PyCRC.CRC16 import CRC16
+from ctypes import c_ushort
 
-from dsmr_parser.objects import MBusObject, CosemObject
+from dsmr_parser.objects import MBusObject, CosemObject, ProfileGenericObject
 from dsmr_parser.exceptions import ParseError, InvalidChecksumError
 
 logger = logging.getLogger(__name__)
@@ -79,7 +79,7 @@ class TelegramParser(object):
                 'incomplete. The checksum and/or content values are missing.'
             )
 
-        calculated_crc = CRC16().calculate(checksum_contents.group(0))
+        calculated_crc = TelegramParser.crc16(checksum_contents.group(0))
         expected_crc = int(checksum_hex.group(0), base=16)
 
         if calculated_crc != expected_crc:
@@ -91,6 +91,29 @@ class TelegramParser(object):
                 )
             )
 
+    @staticmethod
+    def crc16(telegram):
+        crc16_tab = []
+
+        for i in range(0, 256):
+            crc = c_ushort(i).value
+            for j in range(0, 8):
+                if (crc & 0x0001):
+                    crc = c_ushort(crc >> 1).value ^ 0xA001
+                else:
+                    crc = c_ushort(crc >> 1).value
+            crc16_tab.append(hex(crc))
+
+        crcValue = 0x0000
+
+        for c in telegram:
+            d = ord(c)
+            tmp = crcValue ^ d
+            rotated = c_ushort(crcValue >> 8).value
+            crcValue = rotated ^ int(crc16_tab[(tmp & 0x00ff)], 0)
+
+        return crcValue
+
 
 class DSMRObjectParser(object):
     """
@@ -100,19 +123,28 @@ class DSMRObjectParser(object):
     def __init__(self, *value_formats):
         self.value_formats = value_formats
 
+    def _is_line_wellformed(self, line, values):
+        # allows overriding by child class
+        return (values and (len(values) == len(self.value_formats)))
+
+    def _parse_values(self, values):
+        # allows overriding by child class
+        return [self.value_formats[i].parse(value)
+                for i, value in enumerate(values)]
+
     def _parse(self, line):
         # Match value groups, but exclude the parentheses
-        pattern = re.compile(r'((?<=\()[0-9a-zA-Z\.\*]{0,}(?=\)))+')
+        pattern = re.compile(r'((?<=\()[0-9a-zA-Z\.\*\-\:]{0,}(?=\)))')
+
         values = re.findall(pattern, line)
 
+        if not self._is_line_wellformed(line, values):
+            raise ParseError("Invalid '%s' line for '%s'", line, self)
+
         # Convert empty value groups to None for clarity.
         values = [None if value == '' else value for value in values]
 
-        if not values or len(values) != len(self.value_formats):
-            raise ParseError("Invalid '%s' line for '%s'", line, self)
-
-        return [self.value_formats[i].parse(value)
-                for i, value in enumerate(values)]
+        return self._parse_values(values)
 
 
 class MBusParser(DSMRObjectParser):
@@ -181,9 +213,34 @@ class ProfileGenericParser(DSMRObjectParser):
     8) Buffer value 2 (oldest entry of buffer attribute without unit)
     9) Unit of buffer values (Unit of capture objects attribute)
     """
+    def __init__(self, buffer_types, head_parsers, parsers_for_unidentified):
+        self.value_formats = head_parsers
+        self.buffer_types = buffer_types
+        self.parsers_for_unidentified = parsers_for_unidentified
+
+    def _is_line_wellformed(self, line, values):
+        if values and (len(values) >= 2) and (values[0].isdigit()):
+            buffer_length = int(values[0])
+            return (buffer_length <= 10) and (len(values) == (buffer_length * 2 + 2))
+        else:
+            return False
+
+    def _parse_values(self, values):
+        buffer_length = int(values[0])
+        buffer_value_obis_ID = values[1]
+        if (buffer_length > 0):
+            if buffer_value_obis_ID in self.buffer_types:
+                bufferValueParsers = self.buffer_types[buffer_value_obis_ID]
+            else:
+                bufferValueParsers = self.parsers_for_unidentified
+        # add the parsers for the encountered value type z times
+        for _ in range(buffer_length):
+            self.value_formats.extend(bufferValueParsers)
+
+        return [self.value_formats[i].parse(value) for i, value in enumerate(values)]
 
     def parse(self, line):
-        raise NotImplementedError()
+        return ProfileGenericObject(self._parse(line))
 
 
 class ValueParser(object):

dsmr_parser/profile_generic_specifications.py

@@ -0,0 +1,10 @@
+from dsmr_parser.parsers import ValueParser
+from dsmr_parser.value_types import timestamp
+
+PG_FAILURE_EVENT = r'0-0:96.7.19'
+
+PG_HEAD_PARSERS = [ValueParser(int), ValueParser(str)]
+PG_UNIDENTIFIED_BUFFERTYPE_PARSERS = [ValueParser(str), ValueParser(str)]
+BUFFER_TYPES = {
+    PG_FAILURE_EVENT:  [ValueParser(timestamp), ValueParser(int)]
+    }

dsmr_parser/telegram_specifications.py

@@ -1,9 +1,10 @@
 from decimal import Decimal
+from copy import deepcopy
 
 from dsmr_parser import obis_references as obis
-from dsmr_parser.parsers import CosemParser, ValueParser, MBusParser
+from dsmr_parser.parsers import CosemParser, ValueParser, MBusParser, ProfileGenericParser
 from dsmr_parser.value_types import timestamp
-
+from dsmr_parser.profile_generic_specifications import BUFFER_TYPES, PG_HEAD_PARSERS, PG_UNIDENTIFIED_BUFFERTYPE_PARSERS
 
 """
 dsmr_parser.telegram_specifications
@@ -36,8 +37,9 @@ V2_2 = {
             ValueParser(int),
             ValueParser(int),
             ValueParser(int),
-            ValueParser(str),
-            ValueParser(Decimal),
+            ValueParser(str),  # obis ref
+            ValueParser(str),  # unit, position 5
+            ValueParser(Decimal),  # meter reading, position 6
         ),
     }
 }
@@ -57,8 +59,12 @@ V4 = {
         obis.ELECTRICITY_ACTIVE_TARIFF: CosemParser(ValueParser(str)),
         obis.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
         obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
+        obis.SHORT_POWER_FAILURE_COUNT: CosemParser(ValueParser(int)),
         obis.LONG_POWER_FAILURE_COUNT: CosemParser(ValueParser(int)),
-        # POWER_EVENT_FAILURE_LOG: ProfileGenericParser(), TODO
+        obis.POWER_EVENT_FAILURE_LOG:
+            ProfileGenericParser(BUFFER_TYPES,
+                                 PG_HEAD_PARSERS,
+                                 PG_UNIDENTIFIED_BUFFERTYPE_PARSERS),
         obis.VOLTAGE_SAG_L1_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SAG_L2_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SAG_L3_COUNT: CosemParser(ValueParser(int)),
@@ -68,6 +74,9 @@ V4 = {
         obis.TEXT_MESSAGE_CODE: CosemParser(ValueParser(int)),
         obis.TEXT_MESSAGE: CosemParser(ValueParser(str)),
         obis.DEVICE_TYPE: CosemParser(ValueParser(int)),
+        obis.INSTANTANEOUS_CURRENT_L1: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L2: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L3: CosemParser(ValueParser(Decimal)),
         obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: CosemParser(ValueParser(Decimal)),
         obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE: CosemParser(ValueParser(Decimal)),
         obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE: CosemParser(ValueParser(Decimal)),
@@ -88,6 +97,7 @@ V5 = {
         obis.P1_MESSAGE_HEADER: CosemParser(ValueParser(str)),
         obis.P1_MESSAGE_TIMESTAMP: CosemParser(ValueParser(timestamp)),
         obis.EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+        obis.ELECTRICITY_IMPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
         obis.ELECTRICITY_USED_TARIFF_1: CosemParser(ValueParser(Decimal)),
         obis.ELECTRICITY_USED_TARIFF_2: CosemParser(ValueParser(Decimal)),
         obis.ELECTRICITY_DELIVERED_TARIFF_1: CosemParser(ValueParser(Decimal)),
@@ -96,13 +106,23 @@ V5 = {
         obis.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
         obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
         obis.LONG_POWER_FAILURE_COUNT: CosemParser(ValueParser(int)),
-        # POWER_EVENT_FAILURE_LOG: ProfileGenericParser(), TODO
+        obis.SHORT_POWER_FAILURE_COUNT: CosemParser(ValueParser(int)),
+        obis.POWER_EVENT_FAILURE_LOG:
+            ProfileGenericParser(BUFFER_TYPES,
+                                 PG_HEAD_PARSERS,
+                                 PG_UNIDENTIFIED_BUFFERTYPE_PARSERS),
         obis.VOLTAGE_SAG_L1_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SAG_L2_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SAG_L3_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SWELL_L1_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SWELL_L2_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SWELL_L3_COUNT: CosemParser(ValueParser(int)),
+        obis.INSTANTANEOUS_VOLTAGE_L1: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_VOLTAGE_L2: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_VOLTAGE_L3: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L1: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L2: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L3: CosemParser(ValueParser(Decimal)),
         obis.TEXT_MESSAGE: CosemParser(ValueParser(str)),
         obis.DEVICE_TYPE: CosemParser(ValueParser(int)),
         obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: CosemParser(ValueParser(Decimal)),
@@ -120,3 +140,18 @@ V5 = {
 }
 
 ALL = (V2_2, V3, V4, V5)
+
+
+BELGIUM_FLUVIUS = deepcopy(V5)
+BELGIUM_FLUVIUS['objects'].update({
+    obis.BELGIUM_HOURLY_GAS_METER_READING: MBusParser(
+        ValueParser(timestamp),
+        ValueParser(Decimal)
+    )
+})
+
+LUXEMBOURG_SMARTY = deepcopy(V5)
+LUXEMBOURG_SMARTY['objects'].update({
+    obis.LUXEMBOURG_ELECTRICITY_USED_TARIFF_GLOBAL: CosemParser(ValueParser(Decimal)),
+    obis.LUXEMBOURG_ELECTRICITY_DELIVERED_TARIFF_GLOBAL: CosemParser(ValueParser(Decimal)),
+})

setup.py

@@ -4,15 +4,15 @@ setup(
     name='dsmr-parser',
     description='Library to parse Dutch Smart Meter Requirements (DSMR)',
     author='Nigel Dokter',
-    author_email='nigeldokter@gmail.com',
+    author_email='nigel@nldr.net',
     url='https://github.com/ndokter/dsmr_parser',
-    version='0.10',
+    version='0.21',
     packages=find_packages(),
     install_requires=[
         'pyserial>=3,<4',
         'pyserial-asyncio<1',
         'pytz',
-        'PyCRC>=1.2,<2'
+        'Tailer==0.4.1'
     ],
     entry_points={
         'console_scripts': ['dsmr_console=dsmr_parser.__main__:console']

test/experiment_telegram.py

@@ -0,0 +1,8 @@
+from dsmr_parser import telegram_specifications
+from dsmr_parser.objects import Telegram
+from dsmr_parser.parsers import TelegramParser
+from example_telegrams import TELEGRAM_V4_2
+parser = TelegramParser(telegram_specifications.V4)
+telegram = Telegram(TELEGRAM_V4_2, parser, telegram_specifications.V4)
+
+print(telegram)

test/test_parse_v4_2.py

@@ -80,6 +80,12 @@ class TelegramParserV4_2Test(unittest.TestCase):
         assert isinstance(result[obis.CURRENT_ELECTRICITY_DELIVERY].value, Decimal)
         assert result[obis.CURRENT_ELECTRICITY_DELIVERY].value == Decimal('0')
 
+        # SHORT_POWER_FAILURE_COUNT (1-0:96.7.21)
+        assert isinstance(result[obis.SHORT_POWER_FAILURE_COUNT], CosemObject)
+        assert result[obis.SHORT_POWER_FAILURE_COUNT].unit is None
+        assert isinstance(result[obis.SHORT_POWER_FAILURE_COUNT].value, int)
+        assert result[obis.SHORT_POWER_FAILURE_COUNT].value == 15
+
         # LONG_POWER_FAILURE_COUNT (96.7.9)
         assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT], CosemObject)
         assert result[obis.LONG_POWER_FAILURE_COUNT].unit is None
@@ -132,8 +138,26 @@ class TelegramParserV4_2Test(unittest.TestCase):
         assert result[obis.TEXT_MESSAGE].unit is None
         assert result[obis.TEXT_MESSAGE].value is None
 
+        # INSTANTANEOUS_CURRENT_L1 (1-0:31.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L1], CosemObject)
+        assert result[obis.INSTANTANEOUS_CURRENT_L1].unit == 'A'
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L1].value, Decimal)
+        assert result[obis.INSTANTANEOUS_CURRENT_L1].value == Decimal('0')
+
+        # INSTANTANEOUS_CURRENT_L2 (1-0:51.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L2], CosemObject)
+        assert result[obis.INSTANTANEOUS_CURRENT_L2].unit == 'A'
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L2].value, Decimal)
+        assert result[obis.INSTANTANEOUS_CURRENT_L2].value == Decimal('6')
+
+        # INSTANTANEOUS_CURRENT_L3 (1-0:71.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L3], CosemObject)
+        assert result[obis.INSTANTANEOUS_CURRENT_L3].unit == 'A'
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L3].value, Decimal)
+        assert result[obis.INSTANTANEOUS_CURRENT_L3].value == Decimal('2')
+
         # DEVICE_TYPE (0-x:24.1.0)
-        assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
+        assert isinstance(result[obis.DEVICE_TYPE], CosemObject)
         assert result[obis.DEVICE_TYPE].unit is None
         assert isinstance(result[obis.DEVICE_TYPE].value, int)
         assert result[obis.DEVICE_TYPE].value == 3

test/test_parse_v5.py

@@ -87,6 +87,12 @@ class TelegramParserV5Test(unittest.TestCase):
         assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT].value, int)
         assert result[obis.LONG_POWER_FAILURE_COUNT].value == 0
 
+        # SHORT_POWER_FAILURE_COUNT (1-0:96.7.21)
+        assert isinstance(result[obis.SHORT_POWER_FAILURE_COUNT], CosemObject)
+        assert result[obis.SHORT_POWER_FAILURE_COUNT].unit is None
+        assert isinstance(result[obis.SHORT_POWER_FAILURE_COUNT].value, int)
+        assert result[obis.SHORT_POWER_FAILURE_COUNT].value == 13
+
         # VOLTAGE_SAG_L1_COUNT (1-0:32.32.0)
         assert isinstance(result[obis.VOLTAGE_SAG_L1_COUNT], CosemObject)
         assert result[obis.VOLTAGE_SAG_L1_COUNT].unit is None
@@ -123,13 +129,49 @@ class TelegramParserV5Test(unittest.TestCase):
         assert isinstance(result[obis.VOLTAGE_SWELL_L3_COUNT].value, int)
         assert result[obis.VOLTAGE_SWELL_L3_COUNT].value == 0
 
+        # INSTANTANEOUS_VOLTAGE_L1 (1-0:32.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L1], CosemObject)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L1].unit == 'V'
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L1].value, Decimal)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L1].value == Decimal('230.0')
+
+        # INSTANTANEOUS_VOLTAGE_L2 (1-0:52.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L2], CosemObject)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L2].unit == 'V'
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L2].value, Decimal)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L2].value == Decimal('230.0')
+
+        # INSTANTANEOUS_VOLTAGE_L3 (1-0:72.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L3], CosemObject)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L3].unit == 'V'
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L3].value, Decimal)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L3].value == Decimal('229.0')
+
+        # INSTANTANEOUS_CURRENT_L1 (1-0:31.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L1], CosemObject)
+        assert result[obis.INSTANTANEOUS_CURRENT_L1].unit == 'A'
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L1].value, Decimal)
+        assert result[obis.INSTANTANEOUS_CURRENT_L1].value == Decimal('0.48')
+
+        # INSTANTANEOUS_CURRENT_L2 (1-0:51.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L2], CosemObject)
+        assert result[obis.INSTANTANEOUS_CURRENT_L2].unit == 'A'
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L2].value, Decimal)
+        assert result[obis.INSTANTANEOUS_CURRENT_L2].value == Decimal('0.44')
+
+        # INSTANTANEOUS_CURRENT_L3 (1-0:71.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L3], CosemObject)
+        assert result[obis.INSTANTANEOUS_CURRENT_L3].unit == 'A'
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L3].value, Decimal)
+        assert result[obis.INSTANTANEOUS_CURRENT_L3].value == Decimal('0.86')
+
         # TEXT_MESSAGE (0-0:96.13.0)
         assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
         assert result[obis.TEXT_MESSAGE].unit is None
         assert result[obis.TEXT_MESSAGE].value is None
 
         # DEVICE_TYPE (0-x:24.1.0)
-        assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
+        assert isinstance(result[obis.DEVICE_TYPE], CosemObject)
         assert result[obis.DEVICE_TYPE].unit is None
         assert isinstance(result[obis.DEVICE_TYPE].value, int)
         assert result[obis.DEVICE_TYPE].value == 3

test/test_telegram.py

@@ -0,0 +1,322 @@
+import unittest
+import datetime
+import pytz
+
+from dsmr_parser import telegram_specifications
+from dsmr_parser import obis_name_mapping
+from dsmr_parser.objects import CosemObject
+from dsmr_parser.objects import MBusObject
+from dsmr_parser.objects import Telegram
+from dsmr_parser.objects import ProfileGenericObject
+from dsmr_parser.parsers import TelegramParser
+from test.example_telegrams import TELEGRAM_V4_2
+from decimal import Decimal
+
+
+class TelegramTest(unittest.TestCase):
+    """ Test instantiation of Telegram object """
+
+    def __init__(self, *args, **kwargs):
+        self.item_names_tested = []
+        super(TelegramTest, self).__init__(*args, **kwargs)
+
+    def verify_telegram_item(self, telegram, testitem_name, object_type, unit_val, value_type, value_val):
+        testitem = eval("telegram.{}".format(testitem_name))
+        assert isinstance(testitem, object_type)
+        assert testitem.unit == unit_val
+        assert isinstance(testitem.value, value_type)
+        assert testitem.value == value_val
+        self.item_names_tested.append(testitem_name)
+
+    def test_instantiate(self):
+        parser = TelegramParser(telegram_specifications.V4)
+        telegram = Telegram(TELEGRAM_V4_2, parser, telegram_specifications.V4)
+
+        # P1_MESSAGE_HEADER (1-3:0.2.8)
+        self.verify_telegram_item(telegram,
+                                  'P1_MESSAGE_HEADER',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=str,
+                                  value_val='42')
+
+        # P1_MESSAGE_TIMESTAMP (0-0:1.0.0)
+        self.verify_telegram_item(telegram,
+                                  'P1_MESSAGE_TIMESTAMP',
+                                  CosemObject,
+                                  unit_val=None,
+                                  value_type=datetime.datetime,
+                                  value_val=datetime.datetime(2016, 11, 13, 19, 57, 57, tzinfo=pytz.UTC))
+
+        # ELECTRICITY_USED_TARIFF_1 (1-0:1.8.1)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_USED_TARIFF_1',
+                                  object_type=CosemObject,
+                                  unit_val='kWh',
+                                  value_type=Decimal,
+                                  value_val=Decimal('1581.123'))
+
+        # ELECTRICITY_USED_TARIFF_2 (1-0:1.8.2)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_USED_TARIFF_2',
+                                  object_type=CosemObject,
+                                  unit_val='kWh',
+                                  value_type=Decimal,
+                                  value_val=Decimal('1435.706'))
+
+        # ELECTRICITY_DELIVERED_TARIFF_1 (1-0:2.8.1)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_DELIVERED_TARIFF_1',
+                                  object_type=CosemObject,
+                                  unit_val='kWh',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # ELECTRICITY_DELIVERED_TARIFF_2 (1-0:2.8.2)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_DELIVERED_TARIFF_2',
+                                  object_type=CosemObject,
+                                  unit_val='kWh',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # ELECTRICITY_ACTIVE_TARIFF (0-0:96.14.0)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_ACTIVE_TARIFF',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=str,
+                                  value_val='0002')
+
+        # EQUIPMENT_IDENTIFIER (0-0:96.1.1)
+        self.verify_telegram_item(telegram,
+                                  'EQUIPMENT_IDENTIFIER',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=str,
+                                  value_val='3960221976967177082151037881335713')
+
+        # CURRENT_ELECTRICITY_USAGE (1-0:1.7.0)
+        self.verify_telegram_item(telegram,
+                                  'CURRENT_ELECTRICITY_USAGE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('2.027'))
+
+        # CURRENT_ELECTRICITY_DELIVERY (1-0:2.7.0)
+        self.verify_telegram_item(telegram,
+                                  'CURRENT_ELECTRICITY_DELIVERY',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # SHORT_POWER_FAILURE_COUNT (1-0:96.7.21)
+        self.verify_telegram_item(telegram,
+                                  'SHORT_POWER_FAILURE_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=15)
+
+        # LONG_POWER_FAILURE_COUNT (96.7.9)
+        self.verify_telegram_item(telegram,
+                                  'LONG_POWER_FAILURE_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=7)
+
+        # VOLTAGE_SAG_L1_COUNT (1-0:32.32.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SAG_L1_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SAG_L2_COUNT (1-0:52.32.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SAG_L2_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SAG_L3_COUNT (1-0:72.32.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SAG_L3_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SWELL_L1_COUNT (1-0:32.36.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SWELL_L1_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SWELL_L2_COUNT (1-0:52.36.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SWELL_L2_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SWELL_L3_COUNT (1-0:72.36.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SWELL_L3_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # TEXT_MESSAGE_CODE (0-0:96.13.1)
+        self.verify_telegram_item(telegram,
+                                  'TEXT_MESSAGE_CODE',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=type(None),
+                                  value_val=None)
+
+        # TEXT_MESSAGE (0-0:96.13.0)
+        self.verify_telegram_item(telegram,
+                                  'TEXT_MESSAGE',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=type(None),
+                                  value_val=None)
+
+        # INSTANTANEOUS_CURRENT_L1 (1-0:31.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_CURRENT_L1',
+                                  object_type=CosemObject,
+                                  unit_val='A',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # INSTANTANEOUS_CURRENT_L2 (1-0:51.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_CURRENT_L2',
+                                  object_type=CosemObject,
+                                  unit_val='A',
+                                  value_type=Decimal,
+                                  value_val=Decimal('6'))
+
+        # INSTANTANEOUS_CURRENT_L3 (1-0:71.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_CURRENT_L3',
+                                  object_type=CosemObject,
+                                  unit_val='A',
+                                  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',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0.170'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE (1-0:41.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('1.247'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE (1-0:61.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0.209'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE (1-0:22.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE (1-0:42.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE (1-0:62.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
+        self.verify_telegram_item(telegram,
+                                  'EQUIPMENT_IDENTIFIER_GAS',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=str,
+                                  value_val='4819243993373755377509728609491464')
+
+        # HOURLY_GAS_METER_READING (0-1:24.2.1)
+        self.verify_telegram_item(telegram,
+                                  'HOURLY_GAS_METER_READING',
+                                  object_type=MBusObject,
+                                  unit_val='m3',
+                                  value_type=Decimal,
+                                  value_val=Decimal('981.443'))
+
+        # POWER_EVENT_FAILURE_LOG (1-0:99.97.0)
+        testitem_name = 'POWER_EVENT_FAILURE_LOG'
+        object_type = ProfileGenericObject
+        testitem = eval("telegram.{}".format(testitem_name))
+        assert isinstance(testitem, object_type)
+        assert testitem.buffer_length == 3
+        assert testitem.buffer_type == '0-0:96.7.19'
+        buffer = testitem.buffer
+        assert isinstance(testitem.buffer, list)
+        assert len(buffer) == 3
+        assert all([isinstance(item, MBusObject) for item in buffer])
+        date0 = datetime.datetime(2000, 1, 4, 17, 3, 20, tzinfo=datetime.timezone.utc)
+        date1 = datetime.datetime(1999, 12, 31, 23, 0, 1, tzinfo=datetime.timezone.utc)
+        date2 = datetime.datetime(2000, 1, 1, 23, 0, 3, tzinfo=datetime.timezone.utc)
+        assert buffer[0].datetime == date0
+        assert buffer[1].datetime == date1
+        assert buffer[2].datetime == date2
+        assert buffer[0].value == 237126
+        assert buffer[1].value == 2147583646
+        assert buffer[2].value == 2317482647
+        assert all([isinstance(item.value, int) for item in buffer])
+        assert all([isinstance(item.unit, str) for item in buffer])
+        assert all([(item.unit == 's') for item in buffer])
+        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_set = set(V4_name_list)
+        item_names_tested_set = set(self.item_names_tested)
+
+        assert item_names_tested_set == V4_name_set

tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = py34,py35,p36
+envlist = py34,py35,py36,py37
 
 [testenv]
 deps=
@@ -9,7 +9,6 @@ deps=
   pytest-asyncio
   pytest-catchlog
   pytest-mock
-  PyCRC
 commands=
   py.test --cov=dsmr_parser test {posargs}
   pylama dsmr_parser test
@@ -17,8 +16,11 @@ commands=
 [pylama:dsmr_parser/clients/__init__.py]
 ignore = W0611
 
+[pylama:dsmr_parser/parsers.py]
+ignore = W605
+
 [pylama:pylint]
-max_line_length = 100
+max_line_length = 120
 
 [pylama:pycodestyle]
-max_line_length = 100
+max_line_length = 120