Remove kwargs. (#2236)

Author: janiversen

examples/contrib/redis_datastore.py

@@ -17,17 +17,16 @@
 class RedisSlaveContext(ModbusBaseSlaveContext):
     """This is a modbus slave context using redis as a backing store."""
 
-    def __init__(self, **kwargs):
+    def __init__(self, host="localhost", port=6379, prefix="pymodbus", client=None):
         """Initialize the datastores.
 
         :param host: The host to connect to
         :param port: The port to connect to
         :param prefix: A prefix for the keys
+        :param client: redis client
         """
-        host = kwargs.get("host", "localhost")
-        port = kwargs.get("port", 6379)
-        self.prefix = kwargs.get("prefix", "pymodbus")
-        self.client = kwargs.get("client", redis.Redis(host=host, port=port))
+        self.prefix = prefix
+        self.client = client if client else redis.Redis(host=host, port=port)
         self._build_mapping()
 
     def __str__(self):

examples/contrib/sql_datastore.py

@@ -20,17 +20,18 @@
 class SqlSlaveContext(ModbusBaseSlaveContext):
     """This creates a modbus data model with each data access in its a block."""
 
-    def __init__(self, *_args, **kwargs):
+    def __init__(self, *_args, table="pymodbus", database=None):
         """Initialize the datastores.
 
-        :param kwargs: Each element is a ModbusDataBlock
+        :param table: table name
+        :param database: database
         """
         self._engine = None
         self._metadata = None
         self._table = None
         self._connection = None
-        self.table = kwargs.get("table", "pymodbus")
-        self.database = kwargs.get("database", "sqlite:///:memory:")
+        self.table = table
+        self.database = database if database else "sqlite:///:memory:"
         self._db_create(self.table, self.database)
 
     def __str__(self):

pymodbus/datastore/context.py

@@ -92,14 +92,19 @@ class ModbusSlaveContext(ModbusBaseSlaveContext):
 
     """
 
-    def __init__(self, *_args, **kwargs):
+    def __init__(self, *_args,
+                    di=ModbusSequentialDataBlock.create(),
+                    co=ModbusSequentialDataBlock.create(),
+                    ir=ModbusSequentialDataBlock.create(),
+                    hr=ModbusSequentialDataBlock.create(),
+                    zero_mode=False):
         """Initialize the datastores."""
         self.store = {}
-        self.store["d"] = kwargs.get("di", ModbusSequentialDataBlock.create())
-        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", False)
+        self.store["d"] = di
+        self.store["c"] = co
+        self.store["i"] = ir
+        self.store["h"] = hr
+        self.zero_mode = zero_mode
 
     def __str__(self):
         """Return a string representation of the context.

pymodbus/datastore/remote.py

@@ -69,47 +69,47 @@ def __str__(self):
 
     def __build_mapping(self):
         """Build the function code mapper."""
-        kwargs = {}
+        params = {}
         if self.slave:
-            kwargs["slave"] = self.slave
+            params["slave"] = self.slave
         self.__get_callbacks = {
             "d": lambda a, c: self._client.read_discrete_inputs(
-                a, c, **kwargs
+                a, c, **params
             ),
             "c": lambda a, c: self._client.read_coils(
-                a, c, **kwargs
+                a, c, **params
             ),
             "h": lambda a, c: self._client.read_holding_registers(
-                a, c, **kwargs
+                a, c, **params
             ),
             "i": lambda a, c: self._client.read_input_registers(
-                a, c, **kwargs
+                a, c, **params
             ),
         }
         self.__set_callbacks = {
             "d5": lambda a, v: self._client.write_coil(
-                a, v, **kwargs
+                a, v, **params
             ),
             "d15": lambda a, v: self._client.write_coils(
-                a, v, **kwargs
+                a, v, **params
             ),
             "c5": lambda a, v: self._client.write_coil(
-                a, v, **kwargs
+                a, v, **params
             ),
             "c15": lambda a, v: self._client.write_coils(
-                a, v, **kwargs
+                a, v, **params
             ),
             "h6": lambda a, v: self._client.write_register(
-                a, v, **kwargs
+                a, v, **params
             ),
             "h16": lambda a, v: self._client.write_registers(
-                a, v, **kwargs
+                a, v, **params
             ),
             "i6": lambda a, v: self._client.write_register(
-                a, v, **kwargs
+                a, v, **params
             ),
             "i16": lambda a, v: self._client.write_registers(
-                a, v, **kwargs
+                a, v, **params
             ),
         }
         self._write_fc = (0x05, 0x06, 0x0F, 0x10)

pymodbus/device.py

@@ -470,7 +470,7 @@ def __iter__(self):
         """
         return self.__counters.__iter__()
 
-    def __new__(cls, *_args, **_kwargs):
+    def __new__(cls):
         """Create a new instance."""
         if "_inst" not in vars(cls):
             cls._inst = object.__new__(cls)

pymodbus/events.py

@@ -48,11 +48,11 @@ class RemoteReceiveEvent(ModbusEvent):
         7   1
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, overrun=False, listen=False, broadcast=False):
         """Initialize a new event instance."""
-        self.overrun = kwargs.get("overrun", False)
-        self.listen = kwargs.get("listen", False)
-        self.broadcast = kwargs.get("broadcast", False)
+        self.overrun = overrun
+        self.listen = listen
+        self.broadcast = broadcast
 
     def encode(self) -> bytes:
         """Encode the status bits to an event message.
@@ -98,14 +98,14 @@ class RemoteSendEvent(ModbusEvent):
         7   0
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, read=False, slave_abort=False, slave_busy=False, slave_nak=False, write_timeout=False, listen=False):
         """Initialize a new event instance."""
-        self.read = kwargs.get("read", False)
-        self.slave_abort = kwargs.get("slave_abort", False)
-        self.slave_busy = kwargs.get("slave_busy", False)
-        self.slave_nak = kwargs.get("slave_nak", False)
-        self.write_timeout = kwargs.get("write_timeout", False)
-        self.listen = kwargs.get("listen", False)
+        self.read = read
+        self.slave_abort = slave_abort
+        self.slave_busy = slave_busy
+        self.slave_nak = slave_nak
+        self.write_timeout = write_timeout
+        self.listen = listen
 
     def encode(self):
         """Encode the status bits to an event message.

pymodbus/framer/old_framer_ascii.py

@@ -48,10 +48,10 @@ def decode_data(self, data):
             return {"slave": uid, "fcode": fcode}
         return {}
 
-    def frameProcessIncomingPacket(self, single, callback, slave, _tid=None, **kwargs):
+    def frameProcessIncomingPacket(self, single, callback, slave, tid=None):
         """Process new packet pattern."""
         while len(self._buffer):
-            used_len, _tid, dev_id, data = self.message_handler.decode(self._buffer)
+            used_len, tid, dev_id, data = self.message_handler.decode(self._buffer)
             if not data:
                 if not used_len:
                     return

pymodbus/framer/old_framer_base.py

@@ -125,7 +125,7 @@ def populateResult(self, result):
         result.transaction_id = self._header.get("tid", 0)
         result.protocol_id = self._header.get("pid", 0)
 
-    def processIncomingPacket(self, data: bytes, callback, slave, **kwargs):
+    def processIncomingPacket(self, data: bytes, callback, slave, single=False, tid=None):
         """Process new packet pattern.
 
         This takes in a new request packet, adds it to the current
@@ -141,7 +141,8 @@ def processIncomingPacket(self, data: bytes, callback, slave, **kwargs):
         :param callback: The function to send results to
         :param slave: Process if slave id matches, ignore otherwise (could be a
                list of slave ids (server) or single slave id(client/server))
-        :param kwargs:
+        :param single: multiple slave ?
+        :param tid: transaction id
         :raises ModbusIOException:
         """
         Log.debug("Processing: {}", data, ":hex")
@@ -150,11 +151,10 @@ def processIncomingPacket(self, data: bytes, callback, slave, **kwargs):
             return
         if not isinstance(slave, (list, tuple)):
             slave = [slave]
-        single = kwargs.pop("single", False)
-        self.frameProcessIncomingPacket(single, callback, slave, **kwargs)
+        self.frameProcessIncomingPacket(single, callback, slave, tid=tid)
 
     def frameProcessIncomingPacket(
-        self, _single, _callback, _slave, _tid=None, **kwargs
+        self, _single, _callback, _slave, tid=None
     ) -> None:
         """Process new packet pattern."""
 

pymodbus/framer/old_framer_rtu.py

@@ -70,7 +70,7 @@ def decode_data(self, data):
         return {}
 
 
-    def frameProcessIncomingPacket(self, _single, callback, slave, _tid=None, **kwargs):  # noqa: C901
+    def frameProcessIncomingPacket(self, _single, callback, slave, tid=None):  # noqa: C901
         """Process new packet pattern."""
 
         def is_frame_ready(self):

pymodbus/framer/old_framer_socket.py

@@ -59,7 +59,7 @@ def decode_data(self, data):
             }
         return {}
 
-    def frameProcessIncomingPacket(self, single, callback, slave, tid=None, **kwargs):
+    def frameProcessIncomingPacket(self, single, callback, slave, tid=None):
         """Process new packet pattern.
 
         This takes in a new request packet, adds it to the current