Merge pull request #6 from ThyMYthOS/master

Update pymodbus and python dependencies

Author: fucm

.github/workflows/test-python-package.yml

@@ -0,0 +1,26 @@
+name: Test python package
+
+on:
+  push:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: pip install tox
+    - name: Run tests
+      run: tox

.travis.yml

@@ -3,9 +3,9 @@
 </p>
 <p align=center>
     <a href="https://pypi.org/project/pystiebeleltron/"><img src="https://img.shields.io/pypi/v/pystiebeleltron.svg"/></a>
-    <a href="https://travis-ci.org/fucm/python-stiebel-eltron"><img src="https://img.shields.io/travis/fucm/python-stiebel-eltron.svg"/></a>
-    <a href='https://coveralls.io/github/fucm/python-stiebel-eltron?branch=master'><img src='https://coveralls.io/repos/github/fucm/python-stiebel-eltron/badge.svg?branch=master' alt='Coverage Status' /></a>
-  <img src="https://img.shields.io/github/license/fucm/python-stiebel-eltron.svg"/></a>
+    <a href="https://github.com/ThyMYthOS/python-stiebel-eltron/actions/workflows/test-python-package.yml"><img src="https://github.com/ThyMYthOS/python-stiebel-eltron/actions/workflows/test-python-package.yml/badge.svg"/></a>
+    <!--a href='https://coveralls.io/github/fucm/python-stiebel-eltron?branch=master'><img src='https://coveralls.io/repos/github/fucm/python-stiebel-eltron/badge.svg?branch=master' alt='Coverage Status' /></a>
+  <img src="https://img.shields.io/github/license/ThyMYthOS/python-stiebel-eltron.svg"/></a Maybe use https://github.com/marketplace/actions/coverage-badge-->
 </p>
 
 # python-stiebel-eltron
@@ -42,9 +42,9 @@ The sample below shows how to use this Python module.
 
     unit = pyse.StiebelEltronAPI(client, 1)
     unit.update()
-    
+
     print("get_target_temp: {}".format(unit.get_target_temp))
-    
+
     client.close()
 ```
 

README.md

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import time
 from pystiebeleltron import pystiebeleltron as pyse
-from pymodbus.client.sync import ModbusTcpClient as ModbusClient
+from pymodbus.client import ModbusTcpClient as ModbusClient
 
 host_ip = "192.168.1.20"
 host_port = 502

example.py

@@ -17,6 +17,8 @@
 8    | 0 to 255   | 1           | 1           | No     | 1      | 5
 """
 
+from pymodbus.client.mixin import ModbusClientMixin
+
 # Error - sensor lead is missing or disconnected.
 ERROR_NOTAVAILABLE = -60
 # Error - short circuit of the sensor lead.
@@ -176,7 +178,7 @@
 class StiebelEltronAPI():
     """Stiebel Eltron API."""
 
-    def __init__(self, conn, slave, update_on_read=False):
+    def __init__(self, conn: ModbusClientMixin, slave=1, update_on_read=False):
         """Initialize Stiebel Eltron communication."""
         self._conn = conn
         self._block_1_input_regs = B1_REGMAP_INPUT
@@ -190,40 +192,34 @@ def update(self):
         ret = True
         try:
             block_1_result_input = self._conn.read_input_registers(
-                unit=self._slave,
+                slave=self._slave,
                 address=B1_START_ADDR,
                 count=len(self._block_1_input_regs)).registers
             block_2_result_holding = self._conn.read_holding_registers(
-                unit=self._slave,
+                slave=self._slave,
                 address=B2_START_ADDR,
                 count=len(self._block_2_holding_regs)).registers
             block_3_result_input = self._conn.read_input_registers(
-                unit=self._slave,
+                slave=self._slave,
                 address=B3_START_ADDR,
                 count=len(self._block_3_input_regs)).registers
         except AttributeError:
             # The unit does not reply reliably
             ret = False
             print("Modbus read failed")
         else:
-            for k in self._block_1_input_regs:
-                self._block_1_input_regs[k]['value'] = \
-                    block_1_result_input[
-                        self._block_1_input_regs[k]['addr'] - B1_START_ADDR]
+            for v in self._block_1_input_regs.values():
+                v['value'] = block_1_result_input[v['addr'] - B1_START_ADDR]
 
-            for k in self._block_2_holding_regs:
-                self._block_2_holding_regs[k]['value'] = \
-                    block_2_result_holding[
-                        self._block_2_holding_regs[k]['addr'] - B2_START_ADDR]
+            for v in self._block_2_holding_regs.values():
+                v['value'] = block_2_result_holding[v['addr'] - B2_START_ADDR]
 
-            for k in self._block_3_input_regs:
-                self._block_3_input_regs[k]['value'] = \
-                    block_3_result_input[
-                        self._block_3_input_regs[k]['addr'] - B3_START_ADDR]
+            for v in self._block_3_input_regs.values():
+                v['value'] = block_3_result_input[v['addr'] - B3_START_ADDR]
 
         return ret
 
-    def get_conv_val(self, name):
+    def get_conv_val(self, name: str):
         """Read and convert value.
 
         Args:
@@ -262,7 +258,7 @@ def get_conv_val(self, name):
 #    def set_raw_holding_register(self, name, value):
 #        """Write to register by name."""
 #        self._conn.write_register(
-#            unit=self._slave,
+#            slave=self._slave,
 #            address=(self._holding_regs[name]['addr']),
 #            value=value)
 
@@ -280,10 +276,10 @@ def get_target_temp(self):
             self.update()
         return self.get_conv_val('ROOM_TEMP_HEAT_DAY_HC1')
 
-    def set_target_temp(self, temp):
+    def set_target_temp(self, temp: float):
         """Set the target room temperature (day)(HC1)."""
         self._conn.write_register(
-            unit=self._slave,
+            slave=self._slave,
             address=(
                 self._block_2_holding_regs['ROOM_TEMP_HEAT_DAY_HC1']['addr']),
             value=round(temp * 10.0))
@@ -304,10 +300,10 @@ def get_operation(self):
         op_mode = self.get_conv_val('OPERATING_MODE')
         return B2_OPERATING_MODE_READ.get(op_mode, 'UNKNOWN')
 
-    def set_operation(self, mode):
+    def set_operation(self, mode: str):
         """Set the operation mode."""
         self._conn.write_register(
-            unit=self._slave,
+            slave=self._slave,
             address=(self._block_2_holding_regs['OPERATING_MODE']['addr']),
             value=B2_OPERATING_MODE_WRITE.get(mode))
 

pystiebeleltron/pystiebeleltron.py

@@ -1 +1 @@
-pymodbus>=2.1.0
+pymodbus>=3.1.0

requirements.txt

@@ -37,15 +37,15 @@ def run_tests(self):
 
 setup(
     name='pystiebeleltron',
-    version='0.0.1.dev2',
+    version='0.1.1',
     description='Python API for interacting with the Stiebel Eltron ISG web gateway via Modbus for controlling integral ventilation units and heat pumps.',
     long_description=long_description,
     long_description_content_type='text/markdown',
-    url='https://github.com/fucm/python-stiebel-eltron',
-    author='Martin Fuchs',
+    url='https://github.com/ThyMYthOS/python-stiebel-eltron',
+    author='Martin Fuchs, Manuel Stahl',
     license='MIT',
-    python_requires='>=3.4',
-    install_requires=['pymodbus>=2.1.0'],
+    python_requires='>=3.8',
+    install_requires=['pymodbus>=3.1.0'],
     tests_require=['tox'],
     cmdclass={'test': Tox},
     packages=find_packages(exclude=('test', 'test.*')),
@@ -56,9 +56,12 @@ def run_tests(self):
         'Development Status :: 3 - Alpha',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: MIT License',
-        'Programming Language :: Python :: 3.4',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
         'Topic :: Utilities',
     ],
 )

setup.py

@@ -7,20 +7,20 @@
 twisted library as its backend.  This allows it to scale to many thousands
 of nodes which can be helpful for testing monitoring software.
 """
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # import the various server implementations
-# --------------------------------------------------------------------------- # 
-from pymodbus.server.async import StartTcpServer, StopServer
+# --------------------------------------------------------------------------- #
+from pymodbus.server import StartTcpServer, ServerStop
 
 from pymodbus.device import ModbusDeviceIdentification
 from pymodbus.datastore import ModbusSequentialDataBlock
 from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
 
 
 class MockModbusServer(object):
-    # --------------------------------------------------------------------------- # 
+    # --------------------------------------------------------------------------- #
     # configure the service logging
-    # --------------------------------------------------------------------------- # 
+    # --------------------------------------------------------------------------- #
     import logging
     FORMAT = ('%(asctime)-15s %(threadName)-15s'
               ' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
@@ -29,9 +29,9 @@ class MockModbusServer(object):
     log.setLevel(logging.DEBUG)
 
     def run_async_server(self):
-        # ----------------------------------------------------------------------- # 
+        # ----------------------------------------------------------------------- #
         # initialize your data store
-        # ----------------------------------------------------------------------- # 
+        # ----------------------------------------------------------------------- #
         # The datastores only respond to the addresses that they are initialized to
         # Therefore, if you initialize a DataBlock to addresses from 0x00 to 0xFF,
         # a request to 0x100 will respond with an invalid address exception.
@@ -82,17 +82,17 @@ def run_async_server(self):
         # will map to (1-8)::
         #
         #     store = ModbusSlaveContext(..., zero_mode=True)
-        # ----------------------------------------------------------------------- # 
+        # ----------------------------------------------------------------------- #
         store = ModbusSlaveContext(
             hr=ModbusSequentialDataBlock(0, [0]*3000),
             ir=ModbusSequentialDataBlock(0, [0]*3000))
         self.context = ModbusServerContext(slaves=store, single=True)
 
-        # ----------------------------------------------------------------------- # 
+        # ----------------------------------------------------------------------- #
         # initialize the server information
-        # ----------------------------------------------------------------------- # 
+        # ----------------------------------------------------------------------- #
         # If you don't set this or any fields, they are defaulted to empty strings.
-        # ----------------------------------------------------------------------- # 
+        # ----------------------------------------------------------------------- #
         identity = ModbusDeviceIdentification()
         identity.VendorName = 'Pymodbus'
         identity.ProductCode = 'PM'
@@ -101,15 +101,15 @@ def run_async_server(self):
         identity.ModelName = 'Pymodbus Server'
         identity.MajorMinorRevision = '1.5'
 
-        # ----------------------------------------------------------------------- # 
+        # ----------------------------------------------------------------------- #
         # run the server you want
-        # ----------------------------------------------------------------------- # 
+        # ----------------------------------------------------------------------- #
 
         # TCP Server
         StartTcpServer(self.context, identity=identity, address=("localhost", 5020))
 
     def stop_async_server(self):
-        StopServer()
+        ServerStop()
 
     def update_context(self, register, address, values):
         """ Update values of the active context. It should be noted

test/mock_modbus_server.py

@@ -8,7 +8,7 @@
 from test.mock_modbus_server import MockModbusServer as ModbusServer
 
 # Import client requirementss
-from pymodbus.client.sync import ModbusTcpClient as ModbusClient
+from pymodbus.client import ModbusTcpClient as ModbusClient
 from pystiebeleltron import pystiebeleltron as pyse
 
 # Modbus server connection details