Prepare pymodbus/framer for pylint docstyle. (#829)

Author: janiversen

pymodbus/framer/__init__.py

@@ -1,4 +1,4 @@
-"""Framer start."""
+""" Framer start. """
 import struct
 from pymodbus.interfaces import IModbusFramer
 
@@ -13,13 +13,10 @@
 TLS_FRAME_HEADER = BYTE_ORDER + 'B'
 
 class ModbusFramer(IModbusFramer):
-    """
-    Base Framer class
-    """
+    """ Base Framer class. """
 
     def _validate_unit_id(self, units, single):
-        """
-        Validates if the received data is valid for the client
+        """ Validates if the received data is valid for the client
         :param units: list of unit id for which the transaction is valid
         :param single: Set to true to treat this as a single context
         :return:         """
@@ -33,16 +30,14 @@ def _validate_unit_id(self, units, single):
         return self._header['uid'] in units # pylint: disable=no-member
 
     def sendPacket(self, message): # pylint: disable=invalid-name
-        """
-        Sends packets on the bus with 3.5char delay between frames
+        """ Sends packets on the bus with 3.5char delay between frames
         :param message: Message to be sent over the bus
         :return:
         """
         return self.client.send(message) # pylint: disable=no-member
 
     def recvPacket(self, size): # pylint: disable=invalid-name
-        """
-        Receives packet from the bus with specified len
+        """ Receives packet from the bus with specified len
         :param size: Number of bytes to read
         :return:
         """

pymodbus/framer/ascii_framer.py

@@ -21,8 +21,7 @@
 # Modbus ASCII Message
 # --------------------------------------------------------------------------- #
 class ModbusAsciiFramer(ModbusFramer):
-    """
-    Modbus ASCII Frame Controller::
+    """ Modbus ASCII Frame Controller::
 
         [ Start ][Address ][ Function ][ Data ][ LRC ][ End ]
           1c        2c         2c         Nc     2c      2c
@@ -145,8 +144,7 @@ def populateResult(self, result):
     # Public Member Functions
     # ----------------------------------------------------------------------- #
     def processIncomingPacket(self, data, callback, unit, **kwargs): # pylint: disable=arguments-differ
-        """
-        The new packet processing pattern
+        """ The new packet processing pattern
 
         This takes in a new request packet, adds it to the current
         packet stream, and performs framing on it. That is, checks

pymodbus/framer/binary_framer.py

@@ -1,4 +1,4 @@
-"""Binary framer."""
+""" Binary framer. """
 import logging
 import struct
 from pymodbus.exceptions import ModbusIOException
@@ -18,8 +18,7 @@
 
 
 class ModbusBinaryFramer(ModbusFramer): # pylint: disable=too-many-instance-attributes
-    """
-    Modbus Binary Frame Controller::
+    """ Modbus Binary Frame Controller::
 
         [ Start ][Address ][ Function ][ Data ][ CRC ][ End ]
           1b        1b         1b         Nb     2b     1b
@@ -60,7 +59,7 @@ def __init__(self, decoder, client=None):
     # Private Helper Functions
     # ----------------------------------------------------------------------- #
     def decode_data(self, data):
-        """Decode data."""
+        """ Decode data. """
         if len(data) > self._hsize:
             uid = struct.unpack('>B', data[1:2])[0]
             fcode = struct.unpack('>B', data[2:3])[0]
@@ -140,8 +139,7 @@ def populateResult(self, result):
     # Public Member Functions
     # ----------------------------------------------------------------------- #
     def processIncomingPacket(self, data, callback, unit, **kwargs): # pylint: disable=arguments-differ
-        """
-        The new packet processing pattern
+        """ The new packet processing pattern
 
         This takes in a new request packet, adds it to the current
         packet stream, and performs framing on it. That is, checks
@@ -198,8 +196,7 @@ def buildPacket(self, message):
         return packet
 
     def _preflight(self, data):
-        """
-        Preflight buffer test
+        """ Preflight buffer test
 
         This basically scans the buffer for start and end
         tags and if found, escapes them.

pymodbus/framer/rtu_framer.py

@@ -1,4 +1,4 @@
-"""RTU framer."""
+""" RTU framer. """
 # pylint: disable=R0801
 import logging
 import struct
@@ -22,8 +22,7 @@
 # Modbus RTU Message
 # --------------------------------------------------------------------------- #
 class ModbusRtuFramer(ModbusFramer):
-    """
-    Modbus RTU Frame controller::
+    """ Modbus RTU Frame controller::
 
         [ Start Wait ] [Address ][ Function Code] [ Data ][ CRC ][  End Wait  ]
           3.5 chars     1b         1b               Nb      2b      3.5 chars
@@ -72,16 +71,15 @@ def __init__(self, decoder, client=None):
     # Private Helper Functions
     # ----------------------------------------------------------------------- #
     def decode_data(self, data):
-        """Decode data."""
+        """ Decode data. """
         if len(data) > self._hsize:
             uid = int(data[0])
             fcode = int(data[1])
             return dict(unit=uid, fcode=fcode)
         return {}
 
     def checkFrame(self):
-        """
-        Check if the next frame is available.
+        """ Check if the next frame is available.
         Return True if we were successful.
 
         1. Populate header
@@ -98,8 +96,7 @@ def checkFrame(self):
             return False
 
     def advanceFrame(self):
-        """
-        Skip over the current framed message
+        """ Skip over the current framed message
         This allows us to skip over the current message after we have processed
         it or determined that it contains an error. It also has to reset the
         current frame header handle
@@ -110,8 +107,7 @@ def advanceFrame(self):
         self._header = {'uid': 0x00, 'len': 0, 'crc': b'\x00\x00'}
 
     def resetFrame(self): # pylint: disable=invalid-name
-        """
-        Reset the entire message frame.
+        """ Reset the entire message frame.
         This allows us to skip over errors that may be in the stream.
         It is hard to know if we are simply out of sync or if there is
         an error in the stream as we have no way to check the start or
@@ -125,8 +121,7 @@ def resetFrame(self): # pylint: disable=invalid-name
         self._header = {'uid': 0x00, 'len': 0, 'crc': b'\x00\x00'}
 
     def isFrameReady(self):
-        """
-        Check if we should continue decode logic
+        """ Check if we should continue decode logic
         This is meant to be used in a while loop in the decoding phase to let
         the decoder know that there is still data in the buffer.
 
@@ -146,8 +141,7 @@ def isFrameReady(self):
         return True
 
     def populateHeader(self, data=None): # pylint: disable=invalid-name
-        """
-        Try to set the headers `uid`, `len` and `crc`.
+        """ Try to set the headers `uid`, `len` and `crc`.
 
         This method examines `self._buffer` and writes meta
         information into `self._header`.
@@ -168,17 +162,15 @@ def populateHeader(self, data=None): # pylint: disable=invalid-name
         self._header['crc'] = data[size - 2:size]
 
     def addToFrame(self, message):
-        """
-        This should be used before the decoding while loop to add the received
+        """ This should be used before the decoding while loop to add the received
         data to the buffer handle.
 
         :param message: The most recent packet
         """
         self._buffer += message
 
     def getFrame(self):
-        """
-        Get the next frame from the buffer
+        """ Get the next frame from the buffer
 
         :returns: The frame data or ''
         """
@@ -192,8 +184,7 @@ def getFrame(self):
         return b''
 
     def populateResult(self, result):
-        """
-        Populates the modbus result header
+        """ Populates the modbus result header
 
         The serial packets do not have any header information
         that is copied.
@@ -207,8 +198,7 @@ def populateResult(self, result):
     # Public Member Functions
     # ----------------------------------------------------------------------- #
     def processIncomingPacket(self, data, callback, unit, **kwargs): # pylint: disable=arguments-differ
-        """
-        The new packet processing pattern
+        """ The new packet processing pattern
 
         This takes in a new request packet, adds it to the current
         packet stream, and performs framing on it. That is, checks
@@ -246,8 +236,7 @@ def processIncomingPacket(self, data, callback, unit, **kwargs): # pylint: disab
             _logger.debug(txt)
 
     def buildPacket(self, message):
-        """
-        Creates a ready to send modbus packet
+        """ Creates a ready to send modbus packet
 
         :param message: The populated request/response to send
         """
@@ -261,8 +250,7 @@ def buildPacket(self, message):
         return packet
 
     def sendPacket(self, message):
-        """
-        Sends packets on the bus with 3.5char delay between frames
+        """ Sends packets on the bus with 3.5char delay between frames
         :param message: Message to be sent over the bus
         :return:
         """
@@ -303,8 +291,7 @@ def sendPacket(self, message):
         return size
 
     def recvPacket(self, size):
-        """
-        Receives packet from the bus with specified len
+        """ Receives packet from the bus with specified len
         :param size: Number of bytes to read
         :return:
         """
@@ -313,9 +300,7 @@ def recvPacket(self, size):
         return result
 
     def _process(self, callback, error=False):
-        """
-        Process incoming packets irrespective error condition
-        """
+        """ Process incoming packets irrespective error condition. """
         data = self.getRawFrame() if error else self.getFrame()
         result = self.decoder.decode(data)
         if result is None:
@@ -327,9 +312,7 @@ def _process(self, callback, error=False):
         callback(result)  # defer or push to a thread?
 
     def getRawFrame(self): # pylint: disable=invalid-name
-        """
-        Returns the complete buffer
-        """
+        """ Returns the complete buffer. """
         txt = f"Getting Raw Frame - {hexlify_packets(self._buffer)}"
         _logger.debug(txt)
         return self._buffer

pymodbus/framer/socket_framer.py

@@ -1,4 +1,4 @@
-"""Socket framer."""
+""" Socket framer. """
 # pylint: disable=R0801
 import logging
 import struct
@@ -51,9 +51,7 @@ def __init__(self, decoder, client=None):
     # Private Helper Functions
     # ----------------------------------------------------------------------- #
     def checkFrame(self):
-        """
-        Check and decode the next frame Return true if we were successful
-        """
+        """ Check and decode the next frame Return true if we were successful. """
         if self.isFrameReady():
             (self._header['tid'], self._header['pid'],
              self._header['len'], self._header['uid']) = struct.unpack(
@@ -103,8 +101,7 @@ def getFrame(self):
         return self._buffer[self._hsize:length]
 
     def populateResult(self, result):
-        """
-        Populates the modbus result with the transport specific header
+        """ Populates the modbus result with the transport specific header
         information (pid, tid, uid, checksum, etc)
 
         :param result: The response packet
@@ -117,16 +114,15 @@ def populateResult(self, result):
     # Public Member Functions
     # ----------------------------------------------------------------------- #
     def decode_data(self, data):
-        """Decode data."""
+        """ Decode data. """
         if len(data) > self._hsize:
             tid, pid, length, uid, fcode = struct.unpack(SOCKET_FRAME_HEADER,
                                                          data[0:self._hsize+1])
             return dict(tid=tid, pid=pid, length=length, unit=uid, fcode=fcode)
         return {}
 
     def processIncomingPacket(self, data, callback, unit, **kwargs): #NOSONAR pylint: disable=arguments-differ
-        """
-        The new packet processing pattern
+        """ The new packet processing pattern
 
         This takes in a new request packet, adds it to the current
         packet stream, and performs framing on it. That is, checks
@@ -170,9 +166,7 @@ def processIncomingPacket(self, data, callback, unit, **kwargs): #NOSONAR pylint
                 break
 
     def _process(self, callback, error=False):
-        """
-        Process incoming packets irrespective error condition
-        """
+        """ Process incoming packets irrespective error condition. """
         data = self.getRawFrame() if error else self.getFrame()
         result = self.decoder.decode(data)
         if result is None:
@@ -184,8 +178,7 @@ def _process(self, callback, error=False):
         callback(result)  # defer or push to a thread?
 
     def resetFrame(self): # pylint: disable=invalid-name
-        """
-        Reset the entire message frame.
+        """ Reset the entire message frame.
         This allows us to skip ovver errors that may be in the stream.
         It is hard to know if we are simply out of sync or if there is
         an error in the stream as we have no way to check the start or
@@ -196,9 +189,7 @@ def resetFrame(self): # pylint: disable=invalid-name
         self._header = {'tid': 0, 'pid': 0, 'len': 0, 'uid': 0}
 
     def getRawFrame(self): # pylint: disable=invalid-name
-        """
-        Returns the complete buffer
-        """
+        """ Returns the complete buffer. """
         return self._buffer
 
     def buildPacket(self, message):