Trio support

doc/source/example/async_trio_client.rst

@@ -0,0 +1,4 @@
+==================================================
+Async Trio Client Example
+==================================================
+.. literalinclude:: ../../../examples/common/async_trio_client.py

doc/source/example/async_trio_server.rst

@@ -0,0 +1,4 @@
+==================================================
+Async Trio Server Example
+==================================================
+.. literalinclude:: ../../../examples/common/trio_server.py

doc/source/example/modules.rst

@@ -10,6 +10,8 @@ Examples
    async_asyncio_serial_client
    async_tornado_client
    async_tornado_client_serial
+   async_trio_client
+   async_trio_server
    async_twisted_client
    async_twisted_client_serial
    asynchronous_processor

doc/source/library/pymodbus.client.asynchronous.rst

@@ -15,6 +15,7 @@ Subpackages
     pymodbus.client.asynchronous.factory
     pymodbus.client.asynchronous.schedulers
     pymodbus.client.asynchronous.tornado
+    pymodbus.client.asynchronous.trio
     pymodbus.client.asynchronous.twisted
 
 Submodules

doc/source/library/pymodbus.client.asynchronous.trio.rst

@@ -0,0 +1,8 @@
+pymodbus\.client\.asynchronous\.trio package
+===============================================
+
+.. automodule:: pymodbus.client.asynchronous.trio
+    :members:
+    :undoc-members:
+    :show-inheritance:
+

doc/source/library/pymodbus.server.rst

@@ -25,4 +25,11 @@ pymodbus\.server\.sync module
     :undoc-members:
     :show-inheritance:
 
+pymodbus\.server\.trio module
+-----------------------------
+
+.. automodule:: pymodbus.server.trio
+    :members:
+    :undoc-members:
+    :show-inheritance:
 

examples/common/async_trio_client.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+"""
+Pymodbus Asynchronous Client Examples
+--------------------------------------------------------------------------
+
+The following is an example of how to use the asynchronous modbus
+client implementation from pymodbus with Trio.
+
+The example is only valid on Python3.6 and above
+"""
+import contextlib
+import logging
+import sys
+
+from pymodbus.client.asynchronous.tcp import AsyncModbusTCPClient as ModbusClient
+from pymodbus.client.asynchronous import schedulers
+
+import trio
+
+
+async def main():
+    root_logger = logging.getLogger()
+    handler = logging.StreamHandler(stream=sys.stdout)
+    root_logger.addHandler(hdlr=handler)
+    root_logger.setLevel(logging.DEBUG)
+
+    client = ModbusClient(scheduler=schedulers.TRIO, host="127.0.0.1", port=5020)
+
+    with contextlib.suppress(KeyboardInterrupt):
+        async with client.manage_connection() as protocol:
+            while True:
+                response = await protocol.read_coils(address=1, count=1, unit=0x01)
+                print('  response:', response.bits)
+                response = await protocol.read_holding_registers(address=1, count=1, unit=0x01)
+                print('  response:', response.registers)
+                response = await protocol.read_holding_registers(address=10, count=1, unit=0x01)
+                print('  response:', response.registers)
+
+                await trio.sleep(1)
+
+
+trio.run(main)

examples/common/trio_server.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+"""
+Pymodbus Trio Server Example
+--------------------------------------------------------------------------
+
+"""
+import logging
+
+FORMAT = (
+    "%(asctime)-15s %(threadName)-15s"
+    " %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s"
+)
+logging.basicConfig(format=FORMAT)
+log = logging.getLogger()
+log.setLevel(logging.DEBUG)
+
+import functools
+
+from pymodbus.server.trio import tcp_server
+from pymodbus.device import ModbusDeviceIdentification
+from pymodbus.datastore import ModbusSequentialDataBlock
+from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
+
+import trio
+
+
+async def run_server():
+    store = ModbusSlaveContext(
+        di=ModbusSequentialDataBlock(0, [17] * 100),
+        co=ModbusSequentialDataBlock(0, [17] * 100),
+        hr=ModbusSequentialDataBlock(0, [17] * 100),
+        ir=ModbusSequentialDataBlock(0, [17] * 100),
+    )
+
+    context = ModbusServerContext(slaves=store, single=True)
+
+    identity = ModbusDeviceIdentification()
+    identity.VendorName = "Pymodbus"
+    identity.ProductCode = "PM"
+    identity.VendorUrl = "https://github.com/riptideio/pymodbus/"
+    identity.ProductName = "Pymodbus Server"
+    identity.ModelName = "Pymodbus Server"
+    identity.MajorMinorRevision = "2.3.0"
+
+    await trio.serve_tcp(
+        functools.partial(
+            tcp_server,
+            context=context,
+            identity=identity,
+        ),
+        port=5020,
+        host="0.0.0.0",
+    )
+
+
+if __name__ == "__main__":
+    trio.run(run_server)

pymodbus/client/asynchronous/__init__.py

@@ -1,6 +1,6 @@
 """
-Async Modbus Client implementation based on Twisted, tornado and asyncio
-------------------------------------------------------------------------
+Async Modbus Client implementation based on Twisted, tornado, asyncio, and Trio
+-------------------------------------------------------------------------------
 
 Example run::
 
@@ -21,6 +21,9 @@
     # For asyncio based asynchronous client use
     event_loop, client = Client(schedulers.ASYNC_IO, port=5020)
 
+    # For asyncio based asynchronous client use
+    client = Client(schedulers.TRIO, 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.

pymodbus/client/asynchronous/factory/tcp.py

@@ -105,6 +105,25 @@ def async_io_factory(host="127.0.0.1", port=Defaults.Port, framer=None,
     return loop, client
 
 
+def trio_factory(host="127.0.0.1", port=Defaults.Port, framer=None,
+                 source_address=None, timeout=None, **kwargs):
+    """
+    Factory to create Trio based asynchronous tcp clients
+    :param host: Host IP address
+    :param port: Port
+    :param framer: Modbus Framer
+    :param source_address: Bind address
+    :param timeout: Timeout in seconds
+    :param kwargs:
+    :return: tcp client
+    """
+    from pymodbus.client.asynchronous.trio import init_tcp_client
+    proto_cls = kwargs.get("proto_cls", None)
+    client = init_tcp_client(proto_cls=proto_cls, host=host, port=port)
+
+    return client
+
+
 def get_factory(scheduler):
     """
     Gets protocol factory based on the backend scheduler being used
@@ -117,6 +136,8 @@ def get_factory(scheduler):
         return io_loop_factory
     elif scheduler == schedulers.ASYNC_IO:
         return async_io_factory
+    elif scheduler == schedulers.TRIO:
+        return trio_factory
     else:
         LOGGER.warning("Allowed Schedulers: {}, {}, {}".format(
             schedulers.REACTOR, schedulers.IO_LOOP, schedulers.ASYNC_IO

pymodbus/client/asynchronous/schedulers/__init__.py

@@ -7,3 +7,4 @@
 REACTOR = "reactor"
 IO_LOOP = "io_loop"
 ASYNC_IO = "async_io"
+TRIO = "trio"

pymodbus/client/asynchronous/tcp.py

@@ -5,7 +5,7 @@
 from pymodbus.client.asynchronous.factory.tcp import get_factory
 from pymodbus.constants import Defaults
 from pymodbus.compat import IS_PYTHON3, PYTHON_VERSION
-from pymodbus.client.asynchronous.schedulers import ASYNC_IO
+from pymodbus.client.asynchronous.schedulers import ASYNC_IO, TRIO
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +25,7 @@ def __new__(cls, scheduler, host="127.0.0.1", port=Defaults.Port,
             - reactor (Twisted)
             - io_loop (Tornado)
             - async_io (asyncio)
+            - trio (Trio)
         :param scheduler: Backend to use
         :param host: Host IP address
         :param port: Port
@@ -34,11 +35,15 @@ def __new__(cls, scheduler, host="127.0.0.1", port=Defaults.Port,
         :param kwargs: Other extra args specific to Backend being used
         :return:
         """
-        if (not (IS_PYTHON3 and PYTHON_VERSION >= (3, 4))
-                and scheduler == ASYNC_IO):
-            logger.critical("ASYNCIO is supported only on python3")
-            import sys
-            sys.exit(1)
+        if not IS_PYTHON3:
+            if scheduler == ASYNC_IO and PYTHON_VERSION < (3, 4):
+                logger.critical("ASYNCIO is supported only on Python >= 3.4")
+                import sys
+                sys.exit(1)
+            elif scheduler == TRIO and PYTHON_VERSION < (3, 6):
+                logger.critical("TRIO is supported only on Python >= 3.6")
+                import sys
+                sys.exit(1)
         factory_class = get_factory(scheduler)
         yieldable = factory_class(host=host, port=port, framer=framer,
                                   source_address=source_address,