Fix getValue function description (also some PEP8 fixes)

examples/contrib/remote_server_context.py

@@ -73,7 +73,7 @@ def validate(self, fx, address, count=1):
         return not result.isError()
 
     def getValues(self, fx, address, count=1):
-        """ Validates the request to make sure it is in range
+        """ Get `count` values from datastore
 
         :param fx: The function we are working with
         :param address: The starting address
@@ -118,7 +118,8 @@ def __extract_result(self, fx, result):
                 return result.bits
             if fx in ['h', 'i']:
                 return result.registers
-        else: return result
+        else:
+            return result
 
 # -------------------------------------------------------------------------- #
 # Server Context
@@ -152,7 +153,7 @@ def __init__(self, client):
             'i': lambda a, v, s: client.write_registers(a, v, s),
         }
         self._client = client
-        self.slaves = {} # simply a cache
+        self.slaves = {}  # simply a cache
 
     def __str__(self):
         """ Returns a string representation of the context
@@ -187,14 +188,14 @@ def __setitem__(self, slave, context):
         :param slave: The slave context to set
         :param context: The new context to set for this slave
         """
-        raise NotImplementedException() # doesn't make sense here
+        raise NotImplementedException()  # doesn't make sense here
 
     def __delitem__(self, slave):
         """ Wrapper used to access the slave context
 
         :param slave: The slave context to remove
         """
-        raise NotImplementedException() # doesn't make sense here
+        raise NotImplementedException()  # doesn't make sense here
 
     def __getitem__(self, slave):
         """ Used to get access to a slave context

pymodbus/datastore/context.py

@@ -36,7 +36,7 @@ def __init__(self, *args, **kwargs):
         self.store['c'] = kwargs.get('co', ModbusSequentialDataBlock.create())
         self.store['i'] = kwargs.get('ir', ModbusSequentialDataBlock.create())
         self.store['h'] = kwargs.get('hr', ModbusSequentialDataBlock.create())
-        self.zero_mode  = kwargs.get('zero_mode', Defaults.ZeroMode)
+        self.zero_mode = kwargs.get('zero_mode', Defaults.ZeroMode)
 
     def __str__(self):
         ''' Returns a string representation of the context
@@ -58,19 +58,21 @@ def validate(self, fx, address, count=1):
         :param count: The number of values to test
         :returns: True if the request in within range, False otherwise
         '''
-        if not self.zero_mode: address = address + 1
+        if not self.zero_mode:
+            address = address + 1
         _logger.debug("validate[%d] %d:%d" % (fx, address, count))
         return self.store[self.decode(fx)].validate(address, count)
 
     def getValues(self, fx, address, count=1):
-        ''' Validates the request to make sure it is in range
+        ''' Get `count` values from datastore
 
         :param fx: The function we are working with
         :param address: The starting address
         :param count: The number of values to retrieve
         :returns: The requested values from a:a+c
         '''
-        if not self.zero_mode: address = address + 1
+        if not self.zero_mode:
+            address = address + 1
         _logger.debug("getValues[%d] %d:%d" % (fx, address, count))
         return self.store[self.decode(fx)].getValues(address, count)
 
@@ -81,7 +83,8 @@ def setValues(self, fx, address, values):
         :param address: The starting address
         :param values: The new values to be set
         '''
-        if not self.zero_mode: address = address + 1
+        if not self.zero_mode:
+            address = address + 1
         _logger.debug("setValues[%d] %d:%d" % (fx, address, len(values)))
         self.store[self.decode(fx)].setValues(address, values)
 

pymodbus/datastore/database/redis_datastore.py

@@ -5,7 +5,7 @@
 #---------------------------------------------------------------------------#
 # Logging
 #---------------------------------------------------------------------------#
-import logging;
+import logging
 _logger = logging.getLogger(__name__)
 
 
@@ -55,7 +55,7 @@ def validate(self, fx, address, count=1):
         return self._val_callbacks[self.decode(fx)](address, count)
 
     def getValues(self, fx, address, count=1):
-        ''' Validates the request to make sure it is in range
+        ''' Get `count` values from datastore
 
         :param fx: The function we are working with
         :param address: The starting address
@@ -94,28 +94,28 @@ def _build_mapping(self):
         code mapper.
         '''
         self._val_callbacks = {
-            'd' : lambda o, c: self._val_bit('d', o, c),
-            'c' : lambda o, c: self._val_bit('c', o, c),
-            'h' : lambda o, c: self._val_reg('h', o, c),
-            'i' : lambda o, c: self._val_reg('i', o, c),
+            'd': lambda o, c: self._val_bit('d', o, c),
+            'c': lambda o, c: self._val_bit('c', o, c),
+            'h': lambda o, c: self._val_reg('h', o, c),
+            'i': lambda o, c: self._val_reg('i', o, c),
         }
         self._get_callbacks = {
-            'd' : lambda o, c: self._get_bit('d', o, c),
-            'c' : lambda o, c: self._get_bit('c', o, c),
-            'h' : lambda o, c: self._get_reg('h', o, c),
-            'i' : lambda o, c: self._get_reg('i', o, c),
+            'd': lambda o, c: self._get_bit('d', o, c),
+            'c': lambda o, c: self._get_bit('c', o, c),
+            'h': lambda o, c: self._get_reg('h', o, c),
+            'i': lambda o, c: self._get_reg('i', o, c),
         }
         self._set_callbacks = {
-            'd' : lambda o, v: self._set_bit('d', o, v),
-            'c' : lambda o, v: self._set_bit('c', o, v),
-            'h' : lambda o, v: self._set_reg('h', o, v),
-            'i' : lambda o, v: self._set_reg('i', o, v),
+            'd': lambda o, v: self._set_bit('d', o, v),
+            'c': lambda o, v: self._set_bit('c', o, v),
+            'h': lambda o, v: self._set_reg('h', o, v),
+            'i': lambda o, v: self._set_reg('i', o, v),
         }
 
     #--------------------------------------------------------------------------#
     # Redis discrete implementation
     #--------------------------------------------------------------------------#
-    _bit_size    = 16
+    _bit_size = 16
     _bit_default = '\x00' * (_bit_size % 8)
 
     def _get_bit_values(self, key, offset, count):
@@ -129,7 +129,7 @@ def _get_bit_values(self, key, offset, count):
         s = divmod(offset, self._bit_size)[0]
         e = divmod(offset + count, self._bit_size)[0]
 
-        request  = ('%s:%s' % (key, v) for v in range(s, e + 1))
+        request = ('%s:%s' % (key, v) for v in range(s, e + 1))
         response = self.client.mget(request)
         return response
 
@@ -173,7 +173,7 @@ def _set_bit(self, key, offset, values):
         current = (r or self._bit_default for r in current)
         current = ''.join(current)
         current = current[0:offset] + value.decode('utf-8') + current[offset + count:]
-        final   = (current[s:s + self._bit_size] for s in range(0, count, self._bit_size))
+        final = (current[s:s + self._bit_size] for s in range(0, count, self._bit_size))
 
         key = self._get_prefix(key)
         request = ('%s:%s' % (key, v) for v in range(s, e + 1))
@@ -183,7 +183,7 @@ def _set_bit(self, key, offset, values):
     #--------------------------------------------------------------------------#
     # Redis register implementation
     #--------------------------------------------------------------------------#
-    _reg_size    = 16
+    _reg_size = 16
     _reg_default = '\x00' * (_reg_size % 8)
 
     def _get_reg_values(self, key, offset, count):
@@ -198,7 +198,7 @@ def _get_reg_values(self, key, offset, count):
         #e = divmod(offset+count, self.__reg_size)[0]
 
         #request  = ('%s:%s' % (key, v) for v in range(s, e + 1))
-        request  = ('%s:%s' % (key, v) for v in range(offset, count + 1))
+        request = ('%s:%s' % (key, v) for v in range(offset, count + 1))
         response = self.client.mget(request)
         return response
 

pymodbus/datastore/database/sql_datastore.py

@@ -10,7 +10,7 @@
 #---------------------------------------------------------------------------#
 # Logging
 #---------------------------------------------------------------------------#
-import logging;
+import logging
 _logger = logging.getLogger(__name__)
 
 
@@ -57,7 +57,7 @@ def validate(self, fx, address, count=1):
         return self._validate(self.decode(fx), address, count)
 
     def getValues(self, fx, address, count=1):
-        ''' Validates the request to make sure it is in range
+        ''' Get `count` values from datastore
 
         :param fx: The function we are working with
         :param address: The starting address
@@ -91,10 +91,10 @@ def _db_create(self, table, database):
         self._engine = sqlalchemy.create_engine(database, echo=False)
         self._metadata = sqlalchemy.MetaData(self._engine)
         self._table = sqlalchemy.Table(table, self._metadata,
-            sqlalchemy.Column('type', sqltypes.String(1)),
-            sqlalchemy.Column('index', sqltypes.Integer),
-            sqlalchemy.Column('value', sqltypes.Integer),
-            UniqueConstraint('type', 'index', name='key'))
+                                       sqlalchemy.Column('type', sqltypes.String(1)),
+                                       sqlalchemy.Column('index', sqltypes.Integer),
+                                       sqlalchemy.Column('value', sqltypes.Integer),
+                                       UniqueConstraint('type', 'index', name='key'))
         self._table.create(checkfirst=True)
         self._connection = self._engine.connect()
 
@@ -105,7 +105,7 @@ def _get(self, type, offset, count):
         :param count: The number of bits to read
         :returns: The resulting values
         '''
-        query  = self._table.select(and_(
+        query = self._table.select(and_(
             self._table.c.type == type,
             self._table.c.index >= offset,
             self._table.c.index <= offset + count)
@@ -125,9 +125,9 @@ def _build_set(self, type, offset, values, prefix=''):
         result = []
         for index, value in enumerate(values):
             result.append({
-                prefix + 'type'  : type,
-                prefix + 'index' : offset + index,
-                    'value' : value
+                prefix + 'type': type,
+                prefix + 'index': offset + index,
+                'value': value
             })
         return result
 
@@ -144,8 +144,8 @@ def _set(self, type, offset, values):
         '''
         if self._check(type, offset, values):
             context = self._build_set(type, offset, values)
-            query   = self._table.insert()
-            result  = self._connection.execute(query, context)
+            query = self._table.insert()
+            result = self._connection.execute(query, context)
             return result.rowcount == len(values)
         else:
             return False
@@ -158,11 +158,11 @@ def _update(self, type, offset, values):
         :param values: The values to set
         '''
         context = self._build_set(type, offset, values, prefix='x_')
-        query   = self._table.update().values(name='value')
-        query   = query.where(and_(
-            self._table.c.type  == bindparam('x_type'),
+        query = self._table.update().values(name='value')
+        query = query.where(and_(
+            self._table.c.type == bindparam('x_type'),
             self._table.c.index == bindparam('x_index')))
-        result  = self._connection.execute(query, context)
+        result = self._connection.execute(query, context)
         return result.rowcount == len(values)
 
     def _validate(self, type, offset, count):
@@ -172,7 +172,7 @@ def _validate(self, type, offset, count):
         :param count: The number of bits to read
         :returns: The result of the validation
         '''
-        query  = self._table.select(and_(
+        query = self._table.select(and_(
             self._table.c.type == type,
             self._table.c.index >= offset,
             self._table.c.index <= offset + count))

pymodbus/datastore/remote.py

@@ -44,7 +44,7 @@ def validate(self, fx, address, count=1):
         return not result.isError()
 
     def getValues(self, fx, address, count=1):
-        ''' Validates the request to make sure it is in range
+        ''' Get `count` values from datastore
 
         :param fx: The function we are working with
         :param address: The starting address
@@ -100,6 +100,9 @@ def __extract_result(self, fx, result):
         a response.  TODO make this consistent (values?)
         '''
         if not result.isError():
-            if fx in ['d', 'c']: return result.bits
-            if fx in ['h', 'i']: return result.registers
-        else: return result
+            if fx in ['d', 'c']:
+                return result.bits
+            if fx in ['h', 'i']:
+                return result.registers
+        else:
+            return result

pymodbus/interfaces.py

@@ -190,7 +190,7 @@ def validate(self, fx, address, count=1):
         raise NotImplementedException("validate context values")
 
     def getValues(self, fx, address, count=1):
-        ''' Validates the request to make sure it is in range
+        ''' Get `count` values from datastore
 
         :param fx: The function we are working with
         :param address: The starting address
@@ -227,6 +227,7 @@ def build(self):
         '''
         raise NotImplementedException("set context values")
 
+
 #---------------------------------------------------------------------------#
 # Exported symbols
 #---------------------------------------------------------------------------#