Merge pull request #325 from riptideio/#254-Backward-Comaptibility

#254 backward compatibility for asyncio clients with twisted.

Author: dhoomakethu

examples/common/async_twisted_client.py

@@ -20,14 +20,7 @@
 # choose the requested modbus protocol
 # --------------------------------------------------------------------------- #
 
-#from pymodbus.client.async import ModbusUdpClientProtocol
-
 from twisted.internet import reactor, protocol
-from pymodbus.constants import Defaults
-
-# --------------------------------------------------------------------------- #
-# choose the requested modbus protocol
-# --------------------------------------------------------------------------- #
 
 # --------------------------------------------------------------------------- #
 # configure the client logging
@@ -65,6 +58,7 @@ def _assertor(value):
 
 UNIT = 0x01
 
+
 def processResponse(result):
     log.debug(result)
 
@@ -91,6 +85,7 @@ def exampleRequests(client):
 # deferred assert helper(dassert).
 # --------------------------------------------------------------------------- #
 
+
 def stopAsynchronousTest(client):
     # ----------------------------------------------------------------------- #
     # close the client at some time later

examples/contrib/modbus_scraper.py

@@ -11,11 +11,11 @@
 from pymodbus.datastore import ModbusSequentialDataBlock
 from pymodbus.datastore import ModbusSlaveContext
 from pymodbus.factory import ClientDecoder
-from pymodbus.client.async import ModbusClientProtocol
+from pymodbus.client.async.twisted import ModbusClientProtocol
 
-#--------------------------------------------------------------------------#
+# -------------------------------------------------------------------------- #
 # Configure the client logging
-#--------------------------------------------------------------------------#
+# -------------------------------------------------------------------------- #
 import logging
 log = logging.getLogger("pymodbus")
 
@@ -32,14 +32,16 @@
 # --------------------------------------------------------------------------- # 
 COUNT = 8    # The number of bits/registers to read at once
 DELAY = 0    # The delay between subsequent reads
-SLAVE = 0x01 # The slave unit id to read from
+SLAVE = 0x01  # The slave unit id to read from
 
 # --------------------------------------------------------------------------- # 
 # A simple scraper protocol
 # --------------------------------------------------------------------------- # 
 # I tried to spread the load across the device, but feel free to modify the
 # logic to suit your own purpose.
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
+
+
 class ScraperProtocol(ModbusClientProtocol):
 
     address = None
@@ -114,7 +116,8 @@ def start_next_cycle(self, response):
         if self.address >= self.factory.ending:
             self.endpoint.finalize()
             self.transport.loseConnection()
-        else: reactor.callLater(DELAY, self.scrape_holding_registers)
+        else:
+            reactor.callLater(DELAY, self.scrape_holding_registers)
 
     def error_handler(self, failure):
         """ Handle any twisted errors

pymodbus/client/async/__init__.py

@@ -31,75 +31,4 @@
     # For asyncio the actual client is returned and event loop is asyncio loop
 
 """
-from __future__ import unicode_literals
-from __future__ import absolute_import
-
-import logging
-
-from pymodbus.client.sync import BaseModbusClient
-
-from pymodbus.constants import Defaults
-
-from pymodbus.factory import ClientDecoder
-from pymodbus.transaction import ModbusSocketFramer
-
-
-LOGGER = logging.getLogger(__name__)
-
-
-class BaseAsyncModbusClient(BaseModbusClient):
-    """
-    This represents the base ModbusAsyncClient.
-    """
-
-    def __init__(self, framer=None, **kwargs):
-        """ Initializes the framer module
-
-        :param framer: The framer to use for the protocol. Default:
-        ModbusSocketFramer
-        :type framer: pymodbus.transaction.ModbusSocketFramer
-        """
-        self._connected = False
-
-        super(BaseAsyncModbusClient, self).__init__(
-            framer or ModbusSocketFramer(ClientDecoder()), **kwargs
-        )
-
-
-class AsyncModbusClientMixin(BaseAsyncModbusClient):
-    """
-    Async Modbus client mixing for UDP and TCP clients
-    """
-    def __init__(self, host="127.0.0.1", port=Defaults.Port, framer=None,
-                 source_address=None, timeout=None, **kwargs):
-        """
-        Initializes a Modbus TCP/UDP async client
-        :param host: Host IP address
-        :param port: Port
-        :param framer: Framer to use
-        :param source_address: Specific to underlying client being used
-        :param timeout: Timeout in seconds
-        :param kwargs: Extra arguments
-        """
-        super(AsyncModbusClientMixin, self).__init__(framer=framer, **kwargs)
-        self.host = host
-        self.port = port
-        self.source_address = source_address or ("", 0)
-        self.timeout = timeout if timeout is not None else Defaults.Timeout
-
-
-class AsyncModbusSerialClientMixin(BaseAsyncModbusClient):
-    """
-    Async Modbus Serial Client Mixing
-    """
-    def __init__(self, framer=None, port=None, **kwargs):
-        """
-        Initializes a Async Modbus Serial Client
-        :param framer:  Modbus Framer
-        :param port: Serial port to use
-        :param kwargs: Extra arguments if any
-        """
-        super(AsyncModbusSerialClientMixin, self).__init__(framer=framer)
-        self.port = port
-        self.serial_settings = kwargs
-
+from pymodbus.client.async.deprecated.async import *

pymodbus/client/async/asyncio/__init__.py

@@ -5,7 +5,7 @@
 import asyncio
 import functools
 from pymodbus.exceptions import ConnectionException
-from pymodbus.client.async import AsyncModbusClientMixin
+from pymodbus.client.async.mixins import AsyncModbusClientMixin
 from pymodbus.compat import byte2int
 import logging
 

pymodbus/client/async/deprecated/__init__.py

@@ -0,0 +1,47 @@
+import warnings
+warnings.simplefilter('always', DeprecationWarning)
+
+WARNING = """
+Usage of '{}' is deprecated from 2.0.0 and will be removed in future releases.
+Use the new Async Modbus Client implementation based on Twisted, tornado 
+and asyncio
+------------------------------------------------------------------------
+
+Example run::
+
+    from pymodbus.client.async import schedulers
+
+    # Import The clients
+
+    from pymodbus.client.async.tcp import AsyncModbusTCPClient as Client
+    from pymodbus.client.async.serial import AsyncModbusSerialClient as Client
+    from pymodbus.client.async.udp import AsyncModbusUDPClient as Client
+
+    # For tornado based async client use
+    event_loop, future = Client(schedulers.IO_LOOP, port=5020)
+
+    # For twisted based async client use
+    event_loop, deferred = Client(schedulers.REACTOR, port=5020)
+
+    # For asyncio based async client use
+    event_loop, client = Client(schedulers.ASYNC_IO, port=5020)
+
+    # Here event_loop is a thread which would control the backend and future is
+    # a Future/deffered object which would be used to
+    # add call backs to run asynchronously.
+
+    # The Actual client could be accessed with future.result() with Tornado
+    # and future.result when using twisted
+
+    # For asyncio the actual client is returned and event loop is asyncio loop
+
+Refer:
+https://pymodbus.readthedocs.io/en/dev/source/example/async_twisted_client.html
+https://pymodbus.readthedocs.io/en/dev/source/example/async_tornado_client.html
+https://pymodbus.readthedocs.io/en/dev/source/example/async_asyncio_client.html
+
+"""
+
+
+def deprecated(name): # pragma: no cover
+    warnings.warn(WARNING.format(name), DeprecationWarning)