Preparing for release 0.24

Add Luxembourg equipment identifier

.gitignore

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

.travis.yml

@@ -2,9 +2,9 @@ language: python
 
 python:
   - 2.7
-  - 3.4
   - 3.5
   - 3.6
+  - 3.8
   
 install: pip install tox-travis codecov
 

CHANGELOG.rst

@@ -1,6 +1,42 @@
 Change Log
 ----------
 
+**0.24** (2020-11-27)
+- Add Luxembourg equipment identifier (`pull request #62 <https://github.com/ndokter/dsmr_parser/pull/62>`_).
+
+**0.23** (2020-11-07)
+- Resolved issue with x-x:24.3.0 where it contains non-integer character (`pull request #61 <https://github.com/ndokter/dsmr_parser/pull/61>`_).
+- Tests are not installed anymore (`pull request #59 <https://github.com/ndokter/dsmr_parser/pull/59>`_).
+- Example telegram improvement (`pull request #58 <https://github.com/ndokter/dsmr_parser/pull/58>`_).
+
+**0.22** (2020-08-23)
+
+- CRC check speed is improved
+- Exception info improvement
+
+**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>`_).
@@ -32,7 +68,7 @@ Change Log
 
 **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

@@ -56,7 +56,7 @@ into a dictionary.
 
      # String is formatted in separate lines for readability.
      telegram_str = (
-         '/ISk5\2MT382-1000\r\n'
+         '/ISk5\\2MT382-1000\r\n'
          '\r\n'
          '0-0:96.1.1(4B384547303034303436333935353037)\r\n'
          '1-0:1.8.1(12345.678*kWh)\r\n'

dsmr_parser/clients/filereader.py

@@ -1,5 +1,6 @@
 import logging
 import fileinput
+import tailer
 
 from dsmr_parser.clients.telegram_buffer import TelegramBuffer
 from dsmr_parser.exceptions import ParseError, InvalidChecksumError
@@ -8,6 +9,7 @@ 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
@@ -59,7 +61,7 @@ class FileReader(object):
         Read complete DSMR telegram's from a file and return a Telegram object.
         :rtype: generator
         """
-        with open(self._file,"rb") as file_handle:
+        with open(self._file, "rb") as file_handle:
             while True:
                 data = file_handle.readline()
                 str = data.decode()
@@ -73,6 +75,7 @@ class FileReader(object):
                     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
@@ -120,3 +123,49 @@ class FileInputReader(object):
                         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

@@ -29,6 +29,9 @@ def create_dsmr_protocol(dsmr_version, telegram_callback, loop=None):
     elif dsmr_version == '5B':
         specification = telegram_specifications.BELGIUM_FLUVIUS
         serial_settings = SERIAL_SETTINGS_V5
+    elif dsmr_version == "5L":
+        specification = telegram_specifications.LUXEMBOURG_SMARTY
+        serial_settings = SERIAL_SETTINGS_V5
     else:
         raise NotImplementedError("No telegram parser found for version: %s",
                                   dsmr_version)
@@ -59,6 +62,7 @@ def create_tcp_dsmr_reader(host, port, dsmr_version,
     conn = loop.create_connection(protocol, host, port)
     return conn
 
+
 class DSMRProtocol(asyncio.Protocol):
     """Assemble and handle incoming data into complete DSM telegrams."""
 
@@ -94,7 +98,7 @@ class DSMRProtocol(asyncio.Protocol):
     def connection_lost(self, exc):
         """Stop when connection is lost."""
         if exc:
-            self.log.exception('disconnected due to exception')
+            self.log.exception('disconnected due to exception', exc_info=exc)
         else:
             self.log.info('disconnected because of close/abort.')
         self._closed.set()

dsmr_parser/obis_name_mapping.py

@@ -10,45 +10,45 @@ 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'
+    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()])
+REVERSE_EN = dict([(v, k) for k, v in EN.items()])

dsmr_parser/obis_references.py

@@ -63,5 +63,6 @@ ELECTRICITY_DELIVERED_TARIFF_ALL = (
 
 # Alternate codes for foreign countries.
 BELGIUM_HOURLY_GAS_METER_READING = r'\d-\d:24\.2\.3.+?\r\n'  # Different code, same format.
+LUXEMBOURG_EQUIPMENT_IDENTIFIER = r'\d-\d:42\.0\.0.+?\r\n' # Logical device name
 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,4 +1,8 @@
 import dsmr_parser.obis_name_mapping
+import datetime
+import json
+from decimal import Decimal
+
 
 class Telegram(object):
     """
@@ -47,9 +51,12 @@ class Telegram(object):
     def __str__(self):
         output = ""
         for attr, value in self:
-            output += "{}: \t {} \t[{}]\n".format(attr,str(value.value),str(value.unit))
+            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):
     """
@@ -72,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']
 
@@ -82,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):
 
@@ -97,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, Telegram
+from dsmr_parser.objects import MBusObject, CosemObject, ProfileGenericObject
 from dsmr_parser.exceptions import ParseError, InvalidChecksumError
 
 logger = logging.getLogger(__name__)
@@ -11,6 +11,8 @@ logger = logging.getLogger(__name__)
 
 class TelegramParser(object):
 
+    crc16_tab = []
+
     def __init__(self, telegram_specification, apply_checksum_validation=True):
         """
         :param telegram_specification: determines how the telegram is parsed
@@ -79,7 +81,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 +93,33 @@ class TelegramParser(object):
                 )
             )
 
+    @staticmethod
+    def crc16(telegram):
+        """
+        Calculate the CRC16 value for the given telegram
+
+        :param str telegram:
+        """
+        crcValue = 0x0000
+
+        if len(TelegramParser.crc16_tab) == 0:
+            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
+                TelegramParser.crc16_tab.append(hex(crc))
+
+        for c in telegram:
+            d = ord(c)
+            tmp = crcValue ^ d
+            rotated = c_ushort(crcValue >> 8).value
+            crcValue = rotated ^ int(TelegramParser.crc16_tab[(tmp & 0x00ff)], 0)
+
+        return crcValue
+
 
 class DSMRObjectParser(object):
     """
@@ -100,19 +129,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 +219,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

@@ -2,9 +2,9 @@ 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
@@ -34,11 +34,12 @@ V2_2 = {
         obis.VALVE_POSITION_GAS: CosemParser(ValueParser(str)),
         obis.GAS_METER_READING: MBusParser(
             ValueParser(timestamp),
+            ValueParser(str),  # changed to str see issue60
             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
         ),
     }
 }
@@ -58,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)),
@@ -69,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)),
@@ -99,7 +107,10 @@ V5 = {
         obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
         obis.LONG_POWER_FAILURE_COUNT: CosemParser(ValueParser(int)),
         obis.SHORT_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)),
@@ -141,6 +152,7 @@ BELGIUM_FLUVIUS['objects'].update({
 
 LUXEMBOURG_SMARTY = deepcopy(V5)
 LUXEMBOURG_SMARTY['objects'].update({
+    obis.LUXEMBOURG_EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
     obis.LUXEMBOURG_ELECTRICITY_USED_TARIFF_GLOBAL: CosemParser(ValueParser(Decimal)),
     obis.LUXEMBOURG_ELECTRICITY_DELIVERED_TARIFF_GLOBAL: CosemParser(ValueParser(Decimal)),
 })

setup.py

@@ -6,13 +6,13 @@ setup(
     author='Nigel Dokter',
     author_email='nigel@nldr.net',
     url='https://github.com/ndokter/dsmr_parser',
-    version='0.17',
-    packages=find_packages(),
+    version='0.24',
+    packages=find_packages(exclude=('test', 'test.*')),
     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/example_telegrams.py

@@ -1,5 +1,5 @@
 TELEGRAM_V2_2 = (
-    '/ISk5\2MT382-1004\r\n'
+    '/ISk5\\2MT382-1004\r\n'
     '\r\n'
     '0-0:96.1.1(00000000000000)\r\n'
     '1-0:1.8.1(00001.001*kWh)\r\n'
@@ -22,7 +22,7 @@ TELEGRAM_V2_2 = (
 )
 
 TELEGRAM_V3 = (
-    '/ISk5\2MT382-1000\r\n'
+    '/ISk5\\2MT382-1000\r\n'
     '\r\n'
     '0-0:96.1.1(4B384547303034303436333935353037)\r\n'
     '1-0:1.8.1(12345.678*kWh)\r\n'
@@ -87,7 +87,7 @@ TELEGRAM_V4_2 = (
 )
 
 TELEGRAM_V5 = (
-    '/ISk5\2MT382-1000\r\n'
+    '/ISk5\\2MT382-1000\r\n'
     '\r\n'
     '1-3:0.2.8(50)\r\n'
     '0-0:1.0.0(170102192002W)\r\n'
@@ -126,5 +126,5 @@ TELEGRAM_V5 = (
     '0-1:24.2.1(170102161005W)(00000.107*m3)\r\n'
     '0-2:24.1.0(003)\r\n'
     '0-2:96.1.0()\r\n'
-    '!87B3\r\n'
-)
+    '!6EEE\r\n'
+)

test/experiment_telegram.py

@@ -1,14 +1,8 @@
-from decimal import Decimal
-import datetime
-import unittest
-import pytz
-from dsmr_parser import obis_references as obis
 from dsmr_parser import telegram_specifications
-from dsmr_parser.exceptions import InvalidChecksumError, ParseError
-from dsmr_parser.objects import CosemObject, MBusObject, Telegram
+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)
+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

@@ -171,7 +171,7 @@ class TelegramParserV5Test(unittest.TestCase):
         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

@@ -1,30 +1,322 @@
-from decimal import Decimal
-
-import datetime
 import unittest
-
+import datetime
 import pytz
 
-from dsmr_parser import obis_references as obis
 from dsmr_parser import telegram_specifications
-from dsmr_parser.exceptions import InvalidChecksumError, ParseError
-from dsmr_parser.objects import CosemObject, MBusObject, Telegram
+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)
-        #result = parser.parse(TELEGRAM_V4_2)
         telegram = Telegram(TELEGRAM_V4_2, parser, telegram_specifications.V4)
 
-
-
-
         # P1_MESSAGE_HEADER (1-3:0.2.8)
-        #assert isinstance(result[obis.P1_MESSAGE_HEADER], CosemObject)
-        #assert result[obis.P1_MESSAGE_HEADER].unit is None
-        #assert isinstance(result[obis.P1_MESSAGE_HEADER].value, str)
-        #assert result[obis.P1_MESSAGE_HEADER].value == '50'
+        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 = py35,py36,py37,py38
 
 [testenv]
 deps=
@@ -9,16 +9,18 @@ deps=
   pytest-asyncio
   pytest-catchlog
   pytest-mock
-  PyCRC
 commands=
   py.test --cov=dsmr_parser test {posargs}
   pylama dsmr_parser test
 
 [pylama:dsmr_parser/clients/__init__.py]
-ignore = W0611,W0605
+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