datastore: change code to call async_getValues/setValues

messages and serverside defaults to async-calls now and async default is to call the sync version of itself, allowing to build async datastorage functionality

Author: ilkka-ollakka

examples/server_callback.py

@@ -31,15 +31,15 @@ def __init__(self, queue, addr, values):
         self.queue = queue
         super().__init__(addr, values)
 
-    def setValues(self, address, value):
+    async def async_setValues(self, address, value):
         """Set the requested values of the datastore."""
-        super().setValues(address, value)
+        await super().async_setValues(address, value)
         txt = f"Callback from setValues with address {address}, value {value}"
         _logger.debug(txt)
 
-    def getValues(self, address, count=1):
+    async def async_getValues(self, address, count=1):
         """Return the requested values from the datastore."""
-        result = super().getValues(address, count=count)
+        result = await super().async_getValues(address, count=count)
         txt = f"Callback from getValues with address {address}, count {count}, data {result}"
         _logger.debug(txt)
         return result
@@ -56,7 +56,7 @@ async def run_callback_server(cmdline=None):
     """Define datastore callback for server and do setup."""
     queue = asyncio.Queue()
     block = CallbackDataBlock(queue, 0x00, [17] * 100)
-    block.setValues(1, 15)
+    await block.async_setValues(1, 15)
     store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
     context = ModbusServerContext(slaves=store, single=True)
     run_args = server_async.setup_server(

examples/server_updating.py

@@ -61,9 +61,9 @@ async def updating_task(context):
     count = 6
 
     # set values to zero
-    values = context[slave_id].getValues(fc_as_hex, address, count=count)
+    values = await context[slave_id].async_getValues(fc_as_hex, address, count=count)
     values = [0 for v in values]
-    context[slave_id].setValues(fc_as_hex, address, values)
+    await context[slave_id].async_setValues(fc_as_hex, address, values)
 
     txt = (
         f"updating_task: started: initialised values: {values!s} at address {address!s}"
@@ -75,9 +75,11 @@ async def updating_task(context):
     while True:
         await asyncio.sleep(2)
 
-        values = context[slave_id].getValues(fc_as_hex, address, count=count)
+        values = await context[slave_id].async_getValues(
+            fc_as_hex, address, count=count
+        )
         values = [v + 1 for v in values]
-        context[slave_id].setValues(fc_as_hex, address, values)
+        await context[slave_id].async_setValues(fc_as_hex, address, values)
 
         txt = f"updating_task: incremented values: {values!s} at address {address!s}"
         print(txt)

pymodbus/bit_read_message.py

@@ -169,7 +169,9 @@ async def execute(self, context):
             return self.doException(merror.IllegalValue)
         if not context.validate(self.function_code, self.address, self.count):
             return self.doException(merror.IllegalAddress)
-        values = context.getValues(self.function_code, self.address, self.count)
+        values = await context.async_getValues(
+            self.function_code, self.address, self.count
+        )
         if isinstance(values, ExceptionResponse):
             return values
         return ReadCoilsResponse(values)
@@ -237,7 +239,9 @@ async def execute(self, context):
             return self.doException(merror.IllegalValue)
         if not context.validate(self.function_code, self.address, self.count):
             return self.doException(merror.IllegalAddress)
-        values = context.getValues(self.function_code, self.address, self.count)
+        values = await context.async_getValues(
+            self.function_code, self.address, self.count
+        )
         if isinstance(values, ExceptionResponse):
             return values
         return ReadDiscreteInputsResponse(values)

pymodbus/bit_write_message.py

@@ -90,10 +90,12 @@ async def execute(self, context):
         if not context.validate(self.function_code, self.address, 1):
             return self.doException(merror.IllegalAddress)
 
-        result = context.setValues(self.function_code, self.address, [self.value])
+        result = await context.async_setValues(
+            self.function_code, self.address, [self.value]
+        )
         if isinstance(result, ExceptionResponse):
             return result
-        values = context.getValues(self.function_code, self.address, 1)
+        values = await context.async_getValues(self.function_code, self.address, 1)
         if isinstance(values, ExceptionResponse):
             return values
         return WriteSingleCoilResponse(self.address, values[0])
@@ -226,7 +228,9 @@ async def execute(self, context):
         if not context.validate(self.function_code, self.address, count):
             return self.doException(merror.IllegalAddress)
 
-        result = context.setValues(self.function_code, self.address, self.values)
+        result = await context.async_setValues(
+            self.function_code, self.address, self.values
+        )
         if isinstance(result, ExceptionResponse):
             return result
         return WriteMultipleCoilsResponse(self.address, count)

pymodbus/register_read_message.py

@@ -149,7 +149,9 @@ async def execute(self, context):
             return self.doException(merror.IllegalValue)
         if not context.validate(self.function_code, self.address, self.count):
             return self.doException(merror.IllegalAddress)
-        values = context.getValues(self.function_code, self.address, self.count)
+        values = await context.async_getValues(
+            self.function_code, self.address, self.count
+        )
         if isinstance(values, ExceptionResponse):
             return values
 
@@ -210,7 +212,9 @@ async def execute(self, context):
             return self.doException(merror.IllegalValue)
         if not context.validate(self.function_code, self.address, self.count):
             return self.doException(merror.IllegalAddress)
-        values = context.getValues(self.function_code, self.address, self.count)
+        values = await context.async_getValues(
+            self.function_code, self.address, self.count
+        )
         if isinstance(values, ExceptionResponse):
             return values
         return ReadInputRegistersResponse(values)
@@ -328,12 +332,12 @@ async def execute(self, context):
             return self.doException(merror.IllegalAddress)
         if not context.validate(self.function_code, self.read_address, self.read_count):
             return self.doException(merror.IllegalAddress)
-        result = context.setValues(
+        result = await context.async_setValues(
             self.function_code, self.write_address, self.write_registers
         )
         if isinstance(result, ExceptionResponse):
             return result
-        registers = context.getValues(
+        registers = await context.async_getValues(
             self.function_code, self.read_address, self.read_count
         )
         return ReadWriteMultipleRegistersResponse(registers)

pymodbus/register_write_message.py

@@ -68,10 +68,12 @@ async def execute(self, context):
         if not context.validate(self.function_code, self.address, 1):
             return self.doException(merror.IllegalAddress)
 
-        result = context.setValues(self.function_code, self.address, [self.value])
+        result = await context.async_setValues(
+            self.function_code, self.address, [self.value]
+        )
         if isinstance(result, ExceptionResponse):
             return result
-        values = context.getValues(self.function_code, self.address, 1)
+        values = await context.async_getValues(self.function_code, self.address, 1)
         return WriteSingleRegisterResponse(self.address, values[0])
 
     def get_response_pdu_size(self):
@@ -213,7 +215,9 @@ async def execute(self, context):
         if not context.validate(self.function_code, self.address, self.count):
             return self.doException(merror.IllegalAddress)
 
-        result = context.setValues(self.function_code, self.address, self.values)
+        result = await context.async_setValues(
+            self.function_code, self.address, self.values
+        )
         if isinstance(result, ExceptionResponse):
             return result
         return WriteMultipleRegistersResponse(self.address, self.count)
@@ -333,11 +337,13 @@ async def execute(self, context):
             return self.doException(merror.IllegalValue)
         if not context.validate(self.function_code, self.address, 1):
             return self.doException(merror.IllegalAddress)
-        values = context.getValues(self.function_code, self.address, 1)[0]
+        values = (await context.async_getValues(self.function_code, self.address, 1))[0]
         if isinstance(values, ExceptionResponse):
             return values
         values = (values & self.and_mask) | (self.or_mask & ~self.and_mask)
-        result = context.setValues(self.function_code, self.address, [values])
+        result = await context.async_setValues(
+            self.function_code, self.address, [values]
+        )
         if isinstance(result, ExceptionResponse):
             return result
         return MaskWriteRegisterResponse(self.address, self.and_mask, self.or_mask)

test/sub_server/test_simulator.py

@@ -372,7 +372,7 @@ def test_simulator_validate_type(self):
             validated = exc_simulator.validate(entry[0], entry[1], entry[2])
             assert entry[3] == validated, f"at entry {entry}"
 
-    def test_simulator_get_values(self):
+    async def test_simulator_get_values(self):
         """Test simulator get values."""
         for entry in (
             (FX_READ_BIT, 194, 1, [False]),
@@ -382,33 +382,33 @@ def test_simulator_get_values(self):
             (FX_READ_REG, 19, 1, [14662]),
             (FX_READ_REG, 16, 2, [3124, 5678]),
         ):
-            values = self.simulator.getValues(entry[0], entry[1], entry[2])
+            values = await self.simulator.async_getValues(entry[0], entry[1], entry[2])
             assert entry[3] == values, f"at entry {entry}"
 
-    def test_simulator_set_values(self):
+    async def test_simulator_set_values(self):
         """Test simulator set values."""
         exc_setup = copy.deepcopy(self.default_config)
         exc_simulator = ModbusSimulatorContext(exc_setup, None)
         value = [31234]
-        exc_simulator.setValues(FX_WRITE_REG, 16, value)
-        result = exc_simulator.getValues(FX_READ_REG, 16, 1)
+        await exc_simulator.async_setValues(FX_WRITE_REG, 16, value)
+        result = await exc_simulator.async_getValues(FX_READ_REG, 16, 1)
         assert value == result
         value = [31234, 189]
-        exc_simulator.setValues(FX_WRITE_REG, 16, value)
-        result = exc_simulator.getValues(FX_READ_REG, 16, 2)
+        await exc_simulator.async_setValues(FX_WRITE_REG, 16, value)
+        result = await exc_simulator.async_getValues(FX_READ_REG, 16, 2)
         assert value == result
 
         exc_simulator.registers[5].value = 0
-        exc_simulator.setValues(FX_WRITE_BIT, 80, [True])
-        exc_simulator.setValues(FX_WRITE_BIT, 82, [True])
-        exc_simulator.setValues(FX_WRITE_BIT, 84, [True])
-        exc_simulator.setValues(FX_WRITE_BIT, 86, [True, False, True])
-        result = exc_simulator.getValues(FX_READ_BIT, 80, 8)
+        await exc_simulator.async_setValues(FX_WRITE_BIT, 80, [True])
+        await exc_simulator.async_setValues(FX_WRITE_BIT, 82, [True])
+        await exc_simulator.async_setValues(FX_WRITE_BIT, 84, [True])
+        await exc_simulator.async_setValues(FX_WRITE_BIT, 86, [True, False, True])
+        result = await exc_simulator.async_getValues(FX_READ_BIT, 80, 8)
         assert [True, False] * 4 == result
-        exc_simulator.setValues(FX_WRITE_BIT, 88, [False])
-        result = exc_simulator.getValues(FX_READ_BIT, 86, 3)
+        await exc_simulator.async_setValues(FX_WRITE_BIT, 88, [False])
+        result = await exc_simulator.async_getValues(FX_READ_BIT, 86, 3)
         assert [True, False, False] == result
-        exc_simulator.setValues(FX_WRITE_BIT, 80, [True] * 17)
+        await exc_simulator.async_setValues(FX_WRITE_BIT, 80, [True] * 17)
 
     def test_simulator_get_text(self):
         """Test get_text_register()."""
@@ -454,7 +454,7 @@ def test_simulator_get_text(self):
             Label.uptime,
         ],
     )
-    def test_simulator_actions(self, func, addr, action):
+    async def test_simulator_actions(self, func, addr, action):
         """Test actions."""
         exc_setup = copy.deepcopy(self.default_config)
         exc_simulator = ModbusSimulatorContext(exc_setup, None)
@@ -465,20 +465,20 @@ def test_simulator_actions(self, func, addr, action):
         reg2.value = 0
         if func == FX_READ_BIT:
             addr = addr * 16 - 16 + 14
-        values = exc_simulator.getValues(func, addr, 2)
+        values = await exc_simulator.async_getValues(func, addr, 2)
         assert values[0] or values[1]
 
-    def test_simulator_action_timestamp(self):
+    async def test_simulator_action_timestamp(self):
         """Test action timestamp."""
         exc_setup = copy.deepcopy(self.default_config)
         exc_simulator = ModbusSimulatorContext(exc_setup, None)
         addr = 12
         exc_simulator.registers[addr].action = exc_simulator.action_name_to_id[
             Label.timestamp
         ]
-        exc_simulator.getValues(FX_READ_REG, addr, 1)
+        await exc_simulator.async_getValues(FX_READ_REG, addr, 1)
 
-    def test_simulator_action_reset(self):
+    async def test_simulator_action_reset(self):
         """Test action reset."""
         exc_setup = copy.deepcopy(self.default_config)
         exc_simulator = ModbusSimulatorContext(exc_setup, None)
@@ -487,7 +487,7 @@ def test_simulator_action_reset(self):
             Label.reset
         ]
         with pytest.raises(RuntimeError):
-            exc_simulator.getValues(FX_READ_REG, addr, 1)
+            await exc_simulator.async_getValues(FX_READ_REG, addr, 1)
 
     @pytest.mark.parametrize(
         ("celltype", "minval", "maxval", "value", "expected"),
@@ -502,7 +502,7 @@ def test_simulator_action_reset(self):
             (CellType.FLOAT32, 27.0, 75.5, 24.0, (27.0, 28.0, 29.0)),
         ],
     )
-    def test_simulator_action_increment(
+    async def test_simulator_action_increment(
         self, celltype, minval, maxval, value, expected
     ):
         """Test action increment."""
@@ -528,7 +528,7 @@ def test_simulator_action_increment(
         exc_simulator.registers[30].value = regs[0]
         exc_simulator.registers[31].value = regs[1]
         for expect_value in expected:
-            regs = exc_simulator.getValues(FX_READ_REG, 30, reg_count)
+            regs = await exc_simulator.async_getValues(FX_READ_REG, 30, reg_count)
             if reg_count == 1:
                 assert expect_value == regs[0], f"type({celltype})"
             else:
@@ -547,7 +547,7 @@ def test_simulator_action_increment(
             (CellType.FLOAT32, 65.0, 78.0),
         ],
     )
-    def test_simulator_action_random(self, celltype, minval, maxval):
+    async def test_simulator_action_random(self, celltype, minval, maxval):
         """Test action random."""
         exc_setup = copy.deepcopy(self.default_config)
         exc_simulator = ModbusSimulatorContext(exc_setup, None)
@@ -563,7 +563,7 @@ def test_simulator_action_random(self, celltype, minval, maxval):
         is_int = celltype != CellType.FLOAT32
         reg_count = 1 if celltype in (CellType.BITS, CellType.UINT16) else 2
         for _i in range(100):
-            regs = exc_simulator.getValues(FX_READ_REG, 30, reg_count)
+            regs = await exc_simulator.async_getValues(FX_READ_REG, 30, reg_count)
             if reg_count == 1:
                 new_value = regs[0]
             else: