update po file

.github/workflows/python-app.yml

@@ -38,7 +38,7 @@ jobs:
       with:
         fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
     - name: Set up Python 3.13
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v5
       with:
         python-version: "3.13"
     - name: Install dependencies

CHANGELOG.md

@@ -7,14 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [unreleased]
 
-- Update dependency pytest-asyncio to v1.1.0
-- save task references, to avoid a task disappearing mid-execution
-- catch socket.gaierror exception and log this with info level
-- Update dependency coverage to v7.9.2
-- add-on: bump base-image to version 18.0.3
-- add-on: remove armhf and armv7 support
-- add-on: add links to config and log-file to the web-UI
-- fix some SonarQube warnings
 - remove unused 32-bit architectures
 - Babel don't build new po file if only the pot creation-date was changed
 - Improve Makefile

app/docker-bake.hcl

@@ -29,17 +29,17 @@ target "_common" {
     "type =sbom,generator=docker/scout-sbom-indexer:latest"
   ]
   annotations = [
-    "index,manifest-descriptor:org.opencontainers.image.title=TSUN-Proxy",
+    "index:org.opencontainers.image.title=TSUN Gen3 Proxy",
-    "index,manifest-descriptor:org.opencontainers.image.authors=Stefan Allius",
+    "index:org.opencontainers.image.authors=Stefan Allius",
-    "index,manifest-descriptor:org.opencontainers.image.created=${BUILD_DATE}",
+    "index:org.opencontainers.image.created=${BUILD_DATE}",
-    "index,manifest-descriptor:org.opencontainers.image.version=${VERSION}",
+    "index:org.opencontainers.image.version=${VERSION}",
-    "index,manifest-descriptor:org.opencontainers.image.revision=${BRANCH}",
+    "index:org.opencontainers.image.revision=${BRANCH}",
-    "index,manifest-descriptor:org.opencontainers.image.description=${DESCRIPTION}",
+    "index:org.opencontainers.image.description=${DESCRIPTION}",
     "index:org.opencontainers.image.licenses=BSD-3-Clause",
     "index:org.opencontainers.image.source=https://github.com/s-allius/tsun-gen3-proxy"
   ]
   labels = {
-    "org.opencontainers.image.title" = "TSUN-Proxy"
+    "org.opencontainers.image.title" = "TSUN Gen3 Proxy"
     "org.opencontainers.image.authors" = "Stefan Allius"
     "org.opencontainers.image.created" = "${BUILD_DATE}"
     "org.opencontainers.image.version" = "${VERSION}"

app/requirements-test.txt

@@ -1,8 +1,8 @@
     flake8==7.3.0
     pytest==8.4.1
-    pytest-asyncio==1.1.0
+    pytest-asyncio==1.0.0
     pytest-cov==6.2.1
-    python-dotenv==1.1.1
+    python-dotenv==1.1.0
     mock==5.2.0
-    coverage==7.9.2
+    coverage==7.9.1
     jinja2-cli==0.8.2

app/src/gen3plus/solarman_v5.py

@@ -327,7 +327,6 @@ class SolarmanV5(SolarmanBase):
         self.sensor_list = 0
         self.mb_regs = [{'addr': 0x3000, 'len': 48},
                         {'addr': 0x2000, 'len': 96}]
-        self.background_tasks = set()
 
     '''
     Our puplic methods
@@ -340,12 +339,11 @@ class SolarmanV5(SolarmanBase):
         self.inverter = None
         self.switch.clear()
         self.log_lvl.clear()
-        self.background_tasks.clear()
         super().close()
 
-    def send_start_cmd(self, snr: int, host: str,
+    async def send_start_cmd(self, snr: int, host: str,
-                       forward: bool,
+                             forward: bool,
-                       start_timeout=MB_CLIENT_DATA_UP):
+                             start_timeout=MB_CLIENT_DATA_UP):
         self.no_forwarding = True
         self.establish_inv_emu = forward
         self.snr = snr
@@ -692,10 +690,8 @@ class SolarmanV5(SolarmanBase):
         self.__forward_msg()
 
     def publish_mqtt(self, key, data):  # pragma: no cover
-        task = asyncio.ensure_future(
+        asyncio.ensure_future(
             Proxy.mqtt.publish(key, data))
-        self.background_tasks.add(task)
-        task.add_done_callback(self.background_tasks.discard)
 
     def get_cmd_rsp_log_lvl(self) -> int:
         ftype = self.ifc.rx_peek()[self.header_len]

app/src/inverter_base.py

@@ -4,7 +4,6 @@ import logging
 import traceback
 import json
 import gc
-import socket
 from aiomqtt import MqttCodeError
 from asyncio import StreamReader, StreamWriter
 from ipaddress import ip_address
@@ -39,7 +38,6 @@ class InverterBase(InverterIfc, Proxy):
             self.use_emulation = False
         self.__ha_restarts = -1
         self.remote = StreamPtr(None)
-        self.background_tasks = set()
         ifc = AsyncStreamServer(reader, writer,
                                 self.async_publ_mqtt,
                                 self.create_remote,
@@ -74,7 +72,6 @@ class InverterBase(InverterIfc, Proxy):
         if self.remote.ifc:
             self.remote.ifc.close()
             self.remote.ifc = None
-        self.background_tasks.clear()
 
     async def disc(self, shutdown_started=False) -> None:
         if self.remote.stream:
@@ -139,14 +136,9 @@ class InverterBase(InverterIfc, Proxy):
             logging.info(f'[{self.remote.stream.node_id}:'
                          f'{self.remote.stream.conn_no}] '
                          f'Connected to {addr}')
-            task = asyncio.create_task(
+            asyncio.create_task(self.remote.ifc.client_loop(addr))
-                self.remote.ifc.client_loop(addr))
-            self.background_tasks.add(task)
-            task.add_done_callback(self.background_tasks.discard)
 
-        except (ConnectionRefusedError,
+        except (ConnectionRefusedError, TimeoutError) as error:
-                TimeoutError,
-                socket.gaierror) as error:
             logging.info(f'{error}')
         except Exception:
             Infos.inc_counter('SW_Exception')

app/src/messages.py

@@ -193,7 +193,7 @@ class Message(ProtocolIfc):
             return
         self.mb.build_msg(dev_id, func, addr, val, log_lvl)
 
-    def send_modbus_cmd(self, func, addr, val, log_lvl) -> None:
+    async def send_modbus_cmd(self, func, addr, val, log_lvl) -> None:
         self._send_modbus_cmd(Modbus.INV_ADDR, func, addr, val, log_lvl)
 
     def _send_modbus_scan(self):

app/src/modbus_tcp.py

@@ -43,7 +43,6 @@ class ModbusTcp():
 
     def __init__(self, loop, tim_restart=10) -> None:
         self.tim_restart = tim_restart
-        self.background_tasks = set()
 
         inverters = Config.get('inverters')
         batteries = Config.get('batteries')
@@ -55,13 +54,10 @@ class ModbusTcp():
                and 'client_mode' in inv):
                 client = inv['client_mode']
                 logger.info(f"'client_mode' for Monitoring-SN: {inv['monitor_sn']} host: {client['host']}:{client['port']}, forward: {client['forward']}")  # noqa: E501
-                task = loop.create_task(
+                loop.create_task(self.modbus_loop(client['host'],
-                    self.modbus_loop(client['host'],
+                                                  client['port'],
-                                     client['port'],
+                                                  inv['monitor_sn'],
-                                     inv['monitor_sn'],
+                                                  client['forward']))
-                                     client['forward']))
-                self.background_tasks.add(task)
-                task.add_done_callback(self.background_tasks.discard)
 
     async def modbus_loop(self, host, port,
                           snr: int, forward: bool) -> None:
@@ -70,7 +66,7 @@ class ModbusTcp():
             try:
                 async with ModbusConn(host, port) as inverter:
                     stream = inverter.local.stream
-                    stream.send_start_cmd(snr, host, forward)
+                    await stream.send_start_cmd(snr, host, forward)
                     await stream.ifc.loop()
                     logger.info(f'[{stream.node_id}:{stream.conn_no}] '
                                 f'Connection closed - Shutdown: '

app/src/mqtt.py

@@ -112,7 +112,7 @@ class Mqtt(metaclass=Singleton):
             except asyncio.CancelledError:
                 logger_mqtt.debug("MQTT task cancelled")
                 self.__client = None
-                raise
+                return
             except Exception:
                 # self.inc_counter('SW_Exception')   # fixme
                 self.ctime = None
@@ -151,7 +151,7 @@ class Mqtt(metaclass=Singleton):
             if self.__cb_mqtt_is_up:
                 await self.__cb_mqtt_is_up()
 
-    def _out_coeff(self, message):
+    async def _out_coeff(self, message):
         payload = message.payload.decode("UTF-8")
         try:
             val = round(float(payload) * 1024/100)
@@ -160,9 +160,9 @@ class Mqtt(metaclass=Singleton):
                                   'the range 0..100,'
                                   f' got: {payload}')
             else:
-                self._modbus_cmd(message,
+                await self._modbus_cmd(message,
-                                 Modbus.WRITE_SINGLE_REG,
+                                       Modbus.WRITE_SINGLE_REG,
-                                 0, 0x202c, val)
+                                       0, 0x202c, val)
         except Exception:
             pass
 
@@ -182,7 +182,7 @@ class Mqtt(metaclass=Singleton):
         else:
             logger_mqtt.warning(f'Node_id: {node_id} not found')
 
-    def _modbus_cmd(self, message, func, params=0, addr=0, val=0):
+    async def _modbus_cmd(self, message, func, params=0, addr=0, val=0):
         payload = message.payload.decode("UTF-8")
         for fnc in self.each_inverter(message, "send_modbus_cmd"):
             res = payload.split(',')
@@ -195,7 +195,7 @@ class Mqtt(metaclass=Singleton):
             elif params == 2:
                 addr = int(res[0], base=16)
                 val = int(res[1])  # lenght
-            fnc(func, addr, val, logging.INFO)
+            await fnc(func, addr, val, logging.INFO)
 
     async def _at_cmd(self, message):
         payload = message.payload.decode("UTF-8")

app/src/server.py

@@ -60,16 +60,7 @@ class Server():
 
         @app.context_processor
         def utility_processor():
-            var = {'version': self.version,
+            return dict(version=self.version)
-                   'slug': os.getenv("SLUG"),
-                   'hostname': os.getenv("HOSTNAME"),
-                   }
-            if var['slug']:
-                var['hassio'] = True
-                slug_len = len(var['slug'])
-                var['addonname'] = var['slug'] + '_' + \
-                    var['hostname'][slug_len+1:]
-            return var
 
     def parse_args(self, arg_list: list[str] | None):
         parser = argparse.ArgumentParser()
@@ -218,7 +209,6 @@ app = Quart(__name__,
             static_folder='web/static')
 app.secret_key = 'JKLdks.dajlKKKdladkflKwolafallsdfl'
 app.jinja_env.globals.update(url_for=url_for)
-app.background_tasks = set()
 server = Server(app, __name__ == "__main__")
 Web(app, server.trans_path, server.rel_urls)
 
@@ -269,13 +259,9 @@ async def startup_app():    # pragma: no cover
 
     for inv_class, port in [(InverterG3, 5005), (InverterG3P, 10000)]:
         logging.info(f'listen on port: {port} for inverters')
-        task = loop.create_task(
+        loop.create_task(asyncio.start_server(lambda r, w, i=inv_class:
-            asyncio.start_server(lambda r, w, i=inv_class:
+                                              handle_client(r, w, i),
-                                 handle_client(r, w, i),
+                                              '0.0.0.0', port))
-                                 '0.0.0.0', port))
-        app.background_tasks.add(task)
-        task.add_done_callback(app.background_tasks.discard)
-
     ProxyState.set_up(True)
 
 
@@ -299,7 +285,6 @@ async def handle_shutdown():   # pragma: no cover
         await inverter.disc(True)
 
     logging.info('Proxy disconnecting done')
-    app.background_tasks.clear()
 
     await Proxy.class_close(loop)
 

app/src/web/i18n.py

@@ -29,9 +29,9 @@ def get_tz():
 
 @web.context_processor
 def utility_processor():
-    return {'lang': babel_get_locale(),
+    return dict(lang=babel_get_locale(),
-            'lang_str': LANGUAGES.get(str(babel_get_locale()), "English"),
+                lang_str=LANGUAGES.get(str(babel_get_locale()), "English"),
-            'languages': LANGUAGES}
+                languages=LANGUAGES)
 
 
 @web.route('/language/<language>')

app/src/web/log_handler.py

@@ -22,6 +22,3 @@ class LogHandler(Handler, metaclass=Singleton):
 
     def get_buffer(self, elms=0) -> list:
         return list(self.buffer)[-elms:]
-
-    def clear(self):
-        self.buffer.clear()

app/src/web/static/font-awesome/css/all.min.css

@@ -7,4 +7,3 @@
 .fa-rotate-right:before{content:"\f01e"}
 .fa-cloud-arrow-down-alt:before{content:"\f381"}
 .fa-cloud-arrow-up-alt:before{content:"\f382"}
-.fa-gear:before{content:"\f013"}

app/src/web/templates/base.html.j2

@@ -59,11 +59,6 @@
         <a href="{{ url_for('.mqtt')}}" class="w3-bar-item w3-button w3-padding {% block menu2_class %}{% endblock %}"><i class="fa fa-database fa-fw"></i>  MQTT</a>
         <a href="{{ url_for('.notes')}}" class="w3-bar-item w3-button w3-padding {% block menu3_class %}{% endblock %}"><i class="fa fa-info fa-fw"></i>  {{_('Important Messages')}}</a>
         <a href="{{ url_for('.logging')}}" class="w3-bar-item w3-button w3-padding {% block menu4_class %}{% endblock %}"><i class="fa fa-file-export fa-fw"></i>  {{_('Log Files')}}</a>
-        {% if hassio is defined %}
-        <br>
-        <a href="/hassio/addon/{{addonname}}/config" target="_top" class="w3-bar-item w3-button w3-padding"><i class="fa fa-gear fa-fw"></i>  {{_('Add-on Config')}}</a>
-        <a href="/hassio/addon/{{addonname}}/logs" target="_top" class="w3-bar-item w3-button w3-padding"><i class="fa fa-file fa-fw"></i>  {{_('Add-on Log')}}</a>
-        {% endif %}
       </div>
     </nav>
   

app/tests/log/test.txt

@@ -1,19 +1,19 @@
 2025-04-30 00:01:23  INFO | root | Server "proxy - unknown" will be started
-2025-04-30 00:01:24  INFO | root | current dir: /Users/sallius/tsun/tsun-gen3-proxy
+2025-04-30 00:01:23  INFO | root | current dir: /Users/sallius/tsun/tsun-gen3-proxy
-2025-04-30 00:01:25  INFO | root | config_path: ./config/
+2025-04-30 00:01:23  INFO | root | config_path: ./config/
-2025-04-30 00:01:26  INFO | root | json_config: None
+2025-04-30 00:01:23  INFO | root | json_config: None
-2025-04-30 00:01:27  INFO | root | toml_config: None
+2025-04-30 00:01:23  INFO | root | toml_config: None
-2025-04-30 00:01:28  INFO | root | trans_path:  ../translations/
+2025-04-30 00:01:23  INFO | root | trans_path:  ../translations/
-2025-04-30 00:01:29  INFO | root | rel_urls:    False
+2025-04-30 00:01:23  INFO | root | rel_urls:    False
-2025-04-30 00:01:30  INFO | root | log_path:    ./log/
+2025-04-30 00:01:23  INFO | root | log_path:    ./log/
-2025-04-30 00:01:31  INFO | root | log_backups: unlimited
+2025-04-30 00:01:23  INFO | root | log_backups: unlimited
-2025-04-30 00:01:32  INFO | root | LOG_LVL    : None
+2025-04-30 00:01:23  INFO | root | LOG_LVL    : None
-2025-04-30 00:01:33  INFO | root | ******
+2025-04-30 00:01:23  INFO | root | ******
-2025-04-30 00:01:34  INFO | root | Read from /Users/sallius/tsun/tsun-gen3-proxy/app/src/cnf/default_config.toml => ok
+2025-04-30 00:01:23  INFO | root | Read from /Users/sallius/tsun/tsun-gen3-proxy/app/src/cnf/default_config.toml => ok
-2025-04-30 00:01:35  INFO | root | Read from environment => ok
+2025-04-30 00:01:23  INFO | root | Read from environment => ok
-2025-04-30 00:01:36  INFO | root | Read from ./config/config.json => n/a
+2025-04-30 00:01:23  INFO | root | Read from ./config/config.json => n/a
-2025-04-30 00:01:37  INFO | root | Read from ./config/config.toml => n/a
+2025-04-30 00:01:23  INFO | root | Read from ./config/config.toml => n/a
-2025-04-30 00:01:38  INFO | root | ******
+2025-04-30 00:01:23  INFO | root | ******
-2025-04-30 00:01:39  INFO | root | listen on port: 5005 for inverters
+2025-04-30 00:01:23  INFO | root | listen on port: 5005 for inverters
-2025-04-30 00:01:40  INFO | root | listen on port: 10000 for inverters
+2025-04-30 00:01:23  INFO | root | listen on port: 10000 for inverters
-2025-04-30 00:01:41  INFO | root | Start Quart
+2025-04-30 00:01:23  INFO | root | Start Quart

app/tests/test_mqtt.py

@@ -286,23 +286,23 @@ async def test_mqtt_dispatch(config_mqtt_conn, aiomqtt_mock, spy_modbus_cmd):
         assert m.ha_restarts == 1
 
         await m.receive(topic= 'tsun/inv_1/rated_load', payload= b'2')
-        spy.assert_called_once_with(Modbus.WRITE_SINGLE_REG, 0x2008, 2, logging.INFO)
+        spy.assert_awaited_once_with(Modbus.WRITE_SINGLE_REG, 0x2008, 2, logging.INFO)
 
         spy.reset_mock()
         await m.receive(topic= 'tsun/inv_1/out_coeff', payload= b'100')
-        spy.assert_called_once_with(Modbus.WRITE_SINGLE_REG, 0x202c, 1024, logging.INFO)
+        spy.assert_awaited_once_with(Modbus.WRITE_SINGLE_REG, 0x202c, 1024, logging.INFO)
         
         spy.reset_mock()
         await m.receive(topic= 'tsun/inv_1/out_coeff', payload= b'50')
-        spy.assert_called_once_with(Modbus.WRITE_SINGLE_REG, 0x202c, 512, logging.INFO)
+        spy.assert_awaited_once_with(Modbus.WRITE_SINGLE_REG, 0x202c, 512, logging.INFO)
     
         spy.reset_mock()
         await m.receive(topic= 'tsun/inv_1/modbus_read_regs', payload= b'0x3000, 10')
-        spy.assert_called_once_with(Modbus.READ_REGS, 0x3000, 10, logging.INFO)
+        spy.assert_awaited_once_with(Modbus.READ_REGS, 0x3000, 10, logging.INFO)
 
         spy.reset_mock()
         await m.receive(topic= 'tsun/inv_1/modbus_read_inputs', payload= b'0x3000, 10')
-        spy.assert_called_once_with(Modbus.READ_INPUTS, 0x3000, 10, logging.INFO)
+        spy.assert_awaited_once_with(Modbus.READ_INPUTS, 0x3000, 10, logging.INFO)
 
         # test dispatching with empty mapping table
         m.topic_defs.clear()

app/tests/test_server.py

@@ -191,7 +191,6 @@ class TestApp:
         """Test the ready route."""
 
         ProxyState.set_up(False)
-        app.testing = True
         client = app.test_client()
         response = await client.get('/-/ready')
         assert response.status_code == 503
@@ -212,7 +211,6 @@ class TestApp:
 
         with InverterBase(reader, writer, 'tsun', Talent):
             ProxyState.set_up(False)
-            app.testing = True
             client = app.test_client()
             response = await client.get('/-/healthy')
             assert response.status_code == 200
@@ -242,7 +240,6 @@ class TestApp:
 
         with caplog.at_level(logging.INFO) and InverterBase(reader, writer, 'tsun', Talent):
             ProxyState.set_up(False)
-            app.testing = True
             client = app.test_client()
             response = await client.get('/-/healthy')
             assert response.status_code == 200
@@ -274,7 +271,6 @@ class TestApp:
 
         with caplog.at_level(logging.INFO) and InverterBase(reader, writer, 'tsun', Talent):
             ProxyState.set_up(False)
-            app.testing = True
             client = app.test_client()
             response = await client.get('/-/healthy')
             assert response.status_code == 200

app/tests/test_solarman.py

@@ -1624,7 +1624,7 @@ async def test_msg_build_modbus_req(my_loop, config_tsun_inv1, device_ind_msg, d
     assert m.ifc.tx_fifo.get()==device_rsp_msg
     assert m.ifc.fwd_fifo.get()==device_ind_msg
 
-    m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
+    await m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
     assert 0 == m.send_msg_ofs
     assert m.ifc.fwd_fifo.get() == b''
     assert m.sent_pdu == b'' # modbus command must be ignore, cause connection is still not up
@@ -1642,7 +1642,7 @@ async def test_msg_build_modbus_req(my_loop, config_tsun_inv1, device_ind_msg, d
     assert m.ifc.tx_fifo.get()==inverter_rsp_msg
     assert m.ifc.fwd_fifo.get()==inverter_ind_msg
 
-    m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
+    await m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
     assert 0 == m.send_msg_ofs
     assert m.ifc.fwd_fifo.get() == b''
     assert m.sent_pdu == msg_modbus_cmd
@@ -2318,7 +2318,7 @@ async def test_start_client_mode(my_loop, config_tsun_inv1, str_test_ip):
     assert m.no_forwarding == False
     assert m.mb_timer.tim == None
     assert asyncio.get_running_loop() == m.mb_timer.loop
-    m.send_start_cmd(get_sn_int(), str_test_ip, False, m.mb_first_timeout)
+    await m.send_start_cmd(get_sn_int(), str_test_ip, False, m.mb_first_timeout)
     assert m.sent_pdu==bytearray(b'\xa5\x17\x00\x10E\x01\x00!Ce{\x02\xb0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x030\x00\x000J\xde\xf1\x15')
     assert m.db.get_db_value(Register.IP_ADDRESS) == str_test_ip
     assert isclose(m.db.get_db_value(Register.POLLING_INTERVAL), 0.5)
@@ -2351,7 +2351,7 @@ async def test_start_client_mode_scan(config_tsun_scan_dcu, str_test_ip, dcu_mod
     assert m.no_forwarding == False
     assert m.mb_timer.tim == None
     assert asyncio.get_running_loop() == m.mb_timer.loop
-    m.send_start_cmd(get_dcu_sn_int(), str_test_ip, False, m.mb_first_timeout)
+    await m.send_start_cmd(get_dcu_sn_int(), str_test_ip, False, m.mb_first_timeout)
     assert m.mb_start_reg == 0x0000
     assert m.mb_step == 0x100
     assert m.mb_bytes == 0x2d

app/tests/test_solarman_emu.py

@@ -144,7 +144,7 @@ async def test_emu_start(my_loop, config_tsun_inv1, msg_modbus_rsp, str_test_ip,
     inv = InvStream(msg_modbus_rsp)
 
     assert asyncio.get_running_loop() == inv.mb_timer.loop
-    inv.send_start_cmd(get_sn_int(), str_test_ip, True, inv.mb_first_timeout)
+    await inv.send_start_cmd(get_sn_int(), str_test_ip, True, inv.mb_first_timeout)
     inv.read()         # read complete msg, and dispatch msg
     assert not inv.header_valid  # must be invalid, since msg was handled and buffer flushed
     assert inv.msg_count == 1
@@ -161,7 +161,7 @@ async def test_snd_hb(my_loop, config_tsun_inv1, heartbeat_ind):
     inv = InvStream()
     cld = CldStream(inv)
 
-    # inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
+    # await inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
     cld.send_heartbeat_cb(0)
     assert cld.ifc.tx_fifo.peek() == heartbeat_ind
     cld.close()
@@ -178,7 +178,7 @@ async def test_snd_inv_data(my_loop, config_tsun_inv1, inverter_ind_msg, inverte
     inv.db.set_db_def_value(Register.GRID_FREQUENCY, 50.05)
     inv.db.set_db_def_value(Register.PROD_COMPL_TYPE, 6)
     assert asyncio.get_running_loop() == inv.mb_timer.loop
-    inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
+    await inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
     inv.db.set_db_def_value(Register.DATA_UP_INTERVAL, 17)  # set test value
 
     cld = CldStream(inv)
@@ -213,7 +213,7 @@ async def test_rcv_invalid(my_loop, config_tsun_inv1, inverter_ind_msg, inverter
     _ = config_tsun_inv1
     inv = InvStream()
     assert asyncio.get_running_loop() == inv.mb_timer.loop
-    inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
+    await inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
     inv.db.set_db_def_value(Register.DATA_UP_INTERVAL, 17)  # set test value
 
     cld = CldStream(inv)

app/tests/test_talent.py

@@ -2411,14 +2411,14 @@ async def test_msg_build_modbus_req(config_tsun_inv1, msg_modbus_cmd):
     _ = config_tsun_inv1
     m = MemoryStream(b'', (0,), True)
     m.id_str = b"R170000000000001" 
-    m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
+    await m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
     assert 0 == m.send_msg_ofs
     assert m.ifc.fwd_fifo.get() == b''
     assert m.ifc.tx_fifo.get() == b''
     assert m.sent_pdu == b''
 
     m.state = State.up
-    m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
+    await m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
     assert 0 == m.send_msg_ofs
     assert m.ifc.fwd_fifo.get() == b''
     assert m.ifc.tx_fifo.get() == b''

app/tests/test_web_route.py

@@ -1,37 +1,22 @@
 # test_with_pytest.py
 import pytest
-import logging
+from server import app
-import os, errno
+from web import Web, web
-import datetime
-from os import DirEntry, stat_result
-from quart import current_app
-from mock import patch
-
-from server import app as my_app
-from server import Server
-from web import web
 from async_stream import AsyncStreamClient
 from gen3plus.inverter_g3p import InverterG3P
-from web.log_handler import LogHandler
 from test_inverter_g3p import FakeReader, FakeWriter, config_conn
 from cnf.config import Config
+from mock import patch
 from proxy import Proxy
-
+import os, errno
-
+from os import DirEntry, stat_result
-class FakeServer(Server):
+import datetime
-    def __init__(self):
-        pass  # don't call the suoer(.__init__ for unit tests
-
 
 pytest_plugins = ('pytest_asyncio',)
-@pytest.fixture(scope="session")
-def app():
-    yield my_app
 
 @pytest.fixture(scope="session")
-def client(app):
+def client():
     app.secret_key = 'super secret key'
-    app.testing = True
     return app.test_client()
 
 @pytest.fixture
@@ -67,7 +52,6 @@ async def test_home(client):
     response = await client.get('/')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
-    assert b"<title>TSUN Proxy - Connections</title>" in await response.data
 
 @pytest.mark.asyncio
 async def test_page(client):
@@ -75,17 +59,14 @@ async def test_page(client):
     response = await client.get('/mqtt')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
-    assert b"<title>TSUN Proxy - MQTT Status</title>" in await response.data
-    assert b'fetch("/mqtt-fetch")' in await response.data
 
 @pytest.mark.asyncio
 async def test_rel_page(client):
-    """Test the mqtt route with relative paths."""
+    """Test the mqtt route."""
     web.build_relative_urls = True
     response = await client.get('/mqtt')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
-    assert b'fetch("./mqtt-fetch")' in await response.data
     web.build_relative_urls = False
 
 @pytest.mark.asyncio
@@ -94,7 +75,6 @@ async def test_notes(client):
     response = await client.get('/notes')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
-    assert b"<title>TSUN Proxy - Important Messages</title>" in await response.data
 
 @pytest.mark.asyncio
 async def test_logging(client):
@@ -102,7 +82,6 @@ async def test_logging(client):
     response = await client.get('/logging')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
-    assert b"<title>TSUN Proxy - Log Files</title>" in await response.data
 
 @pytest.mark.asyncio
 async def test_favicon96(client):
@@ -140,37 +119,37 @@ async def test_manifest(client):
     assert response.mimetype == 'application/manifest+json'
 
 @pytest.mark.asyncio
-async def test_data_fetch(client, create_inverter):
+async def test_data_fetch(create_inverter):
     """Test the data-fetch route."""
     _ = create_inverter
+    client = app.test_client()
     response = await client.get('/data-fetch')
     assert response.status_code == 200
 
     response = await client.get('/data-fetch')
     assert response.status_code == 200
-    assert b'<h5>Connections</h5>' in await response.data
 
 @pytest.mark.asyncio
-async def test_data_fetch1(client, create_inverter_server):
+async def test_data_fetch1(create_inverter_server):
     """Test the data-fetch route with server connection."""
     _ = create_inverter_server
+    client = app.test_client()
     response = await client.get('/data-fetch')
     assert response.status_code == 200
 
     response = await client.get('/data-fetch')
     assert response.status_code == 200
-    assert b'<h5>Connections</h5>' in await response.data
 
 @pytest.mark.asyncio
-async def test_data_fetch2(client, create_inverter_client):
+async def test_data_fetch2(create_inverter_client):
     """Test the data-fetch route with client connection."""
     _ = create_inverter_client
+    client = app.test_client()
     response = await client.get('/data-fetch')
     assert response.status_code == 200
 
     response = await client.get('/data-fetch')
     assert response.status_code == 200
-    assert b'<h5>Connections</h5>' in await response.data
 
 @pytest.mark.asyncio
 async def test_language_en(client):
@@ -180,44 +159,21 @@ async def test_language_en(client):
     assert response.content_language.pop() == 'en'
     assert response.location == '/index'
     assert response.mimetype == 'text/html'
-    assert b'<html lang=en' in await response.data
-    assert b'<title>Redirecting...</title>' in await response.data
 
     client.set_cookie('test', key='language', value='de')
-    response = await client.get('/')
+    response = await client.get('/mqtt')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
-    assert b'<html lang="en"' in await response.data
-    assert b'<title>TSUN Proxy - Connections</title>' in await response.data
 
 @pytest.mark.asyncio
 async def test_language_de(client):
     """Test the language/de route."""
-
     response = await client.get('/language/de', headers={'referer': '/'})
     assert response.status_code == 302
     assert response.content_language.pop() == 'de'
     assert response.location == '/'
     assert response.mimetype == 'text/html'
-    assert b'<html lang=en>' in await response.data
-    assert b'<title>Redirecting...</title>' in await response.data
 
-    client.set_cookie('test', key='language', value='en')
-    response = await client.get('/')
-    assert response.status_code == 200
-    assert response.mimetype == 'text/html'
-    assert b'<html lang="de"' in await response.data
-    # the following assert fails on github runner, since the translation to german fails
-    # assert b'<title>TSUN Proxy - Verbindungen</title>' in await response.data 
-
-    """Switch back to english"""
-    response = await client.get('/language/en', headers={'referer': '/index'})
-    assert response.status_code == 302
-    assert response.content_language.pop() == 'en'
-    assert response.location == '/index'
-    assert response.mimetype == 'text/html'
-    assert b'<html lang=en>' in await response.data
-    assert b'<title>Redirecting...</title>' in await response.data
 
 @pytest.mark.asyncio
 async def test_language_unknown(client):
@@ -226,12 +182,6 @@ async def test_language_unknown(client):
     assert response.status_code == 404
     assert response.mimetype == 'text/html'
 
-    client.set_cookie('test', key='language', value='en')
-    response = await client.get('/')
-    assert response.status_code == 200
-    assert response.mimetype == 'text/html'
-    assert b'<title>TSUN Proxy - Connections</title>' in await response.data
-
 
 @pytest.mark.asyncio
 async def test_mqtt_fetch(client, create_inverter):
@@ -241,47 +191,15 @@ async def test_mqtt_fetch(client, create_inverter):
 
     response = await client.get('/mqtt-fetch')
     assert response.status_code == 200
-    assert b'<h5>MQTT devices</h5>' in await response.data
 
 
 @pytest.mark.asyncio
 async def test_notes_fetch(client, config_conn):
     """Test the notes-fetch route."""
-    _ = config_conn
+    _ = create_inverter
 
-    s = FakeServer()
-    s.src_dir = 'app/src/'
-    s.init_logging_system()
-
-    # First clear log and test Well done message
-    logh = LogHandler()
-    logh.clear()
     response = await client.get('/notes-fetch')
     assert response.status_code == 200
-    assert b'<h2>Well done!</h2>' in await response.data
-
-    # Check info logs which must be ignored here
-    logging.info('config_info')
-    logh.flush()
-    response = await client.get('/notes-fetch')
-    assert response.status_code == 200
-    assert b'<h2>Well done!</h2>' in await response.data
-
-    # Check warning logs which must be added to the note list
-    logging.warning('config_warning')
-    logh.flush()
-    response = await client.get('/notes-fetch')
-    assert response.status_code == 200
-    assert b'WARNING' in await response.data
-    assert b'config_warning' in await response.data
-
-    # Check error logs which must be added to the note list
-    logging.error('config_err')
-    logh.flush()
-    response = await client.get('/notes-fetch')
-    assert response.status_code == 200
-    assert b'ERROR' in await response.data
-    assert b'config_err' in await response.data
 
 
 @pytest.mark.asyncio
@@ -311,7 +229,6 @@ async def test_file_fetch(client, config_conn, monkeypatch):
     monkeypatch.delattr(stat_result, "st_birthtime")
     response = await client.get('/file-fetch')
     assert response.status_code == 200
-    assert b'<h4>test.txt</h4>' in await response.data
 
 @pytest.mark.asyncio
 async def test_send_file(client, config_conn):
@@ -320,7 +237,6 @@ async def test_send_file(client, config_conn):
     assert Config.log_path == 'app/tests/log/'
     response = await client.get('/send-file/test.txt')
     assert response.status_code == 200
-    assert b'2025-04-30 00:01:23' in await response.data
 
 
 @pytest.mark.asyncio
@@ -375,20 +291,3 @@ async def test_del_file_err(client, config_conn, patch_os_remove_err):
     assert Config.log_path == 'app/tests/log/'
     response = await client.delete ('/del-file/test.txt')
     assert response.status_code == 404
-
-@pytest.mark.asyncio
-async def test_addon_links(client):
-    """Test links to HA add-on config/log in UI"""
-    with patch.dict(os.environ, {'SLUG': 'c676133d', 'HOSTNAME': 'c676133d-tsun-proxy'}):
-        response = await client.get('/')
-        assert response.status_code == 200
-        assert response.mimetype == 'text/html'
-        assert b'Add-on Config' in await response.data
-        assert b'href="/hassio/addon/c676133d_tsun-proxy/logs' in await response.data
-        assert b'href="/hassio/addon/c676133d_tsun-proxy/config' in await response.data
-
-    # check that links are not available if env vars SLUG and HOSTNAME are not defined (docker version)    
-    response = await client.get('/')
-    assert response.status_code == 200
-    assert response.mimetype == 'text/html'
-    assert b'Add-on Config' not in await response.data

app/translations/de/LC_MESSAGES/messages.po

@@ -75,14 +75,6 @@ msgstr "Wichtige Hinweise"
 msgid "Log Files"
 msgstr "Log Dateien"
 
-#: src/web/templates/base.html.j2:64
-msgid "Add-on Config"
-msgstr "Add-on Konfiguration"
-
-#: src/web/templates/base.html.j2:65
-msgid "Add-on Log"
-msgstr "Add-on Protokoll"
-
 #: src/web/templates/page_index.html.j2:3
 msgid "TSUN Proxy - Connections"
 msgstr "TSUN Proxy - Verbindungen"

ha_addons/docker-bake.hcl

@@ -29,23 +29,27 @@ target "_common" {
     "type =sbom,generator=docker/scout-sbom-indexer:latest"
   ]
   annotations = [
+    "index:io.hass.version=${VERSION}",
     "index:io.hass.type=addon",
-    "index:io.hass.arch=aarch64|amd64",
+    "index:io.hass.arch=armhf|aarch64|i386|amd64",
-    "index,manifest-descriptor:org.opencontainers.image.title=TSUN-Proxy",
+    "index:org.opencontainers.image.title=TSUN-Proxy",
-    "index,manifest-descriptor:org.opencontainers.image.authors=Stefan Allius",
+    "index:org.opencontainers.image.authors=Stefan Allius",
-    "index,manifest-descriptor:org.opencontainers.image.created=${BUILD_DATE}",
+    "index:org.opencontainers.image.created=${BUILD_DATE}",
-    "index,manifest-descriptor:org.opencontainers.image.version=${VERSION}",
+    "index:org.opencontainers.image.version=${VERSION}",
-    "index,manifest-descriptor:org.opencontainers.image.description=${DESCRIPTION}",
+    "index:org.opencontainers.image.revision=${BRANCH}",
+    "index:org.opencontainers.image.description=${DESCRIPTION}",
     "index:org.opencontainers.image.licenses=BSD-3-Clause",
-    "index:org.opencontainers.image.source=https://github.com/s-allius/tsun-gen3-proxy/ha_addons/ha_addon",
+    "index:org.opencontainers.image.source=https://github.com/s-allius/tsun-gen3-proxy/ha_addons/ha_addon"
   ]
   labels = {
+    "io.hass.version" = "${VERSION}"
     "io.hass.type" = "addon"
-    "io.hass.arch" = "aarch64|amd64"
+    "io.hass.arch" = "armhf|aarch64|i386|amd64"
     "org.opencontainers.image.title" = "TSUN-Proxy"
     "org.opencontainers.image.authors" = "Stefan Allius"
     "org.opencontainers.image.created" = "${BUILD_DATE}"
     "org.opencontainers.image.version" = "${VERSION}"
+    "org.opencontainers.image.revision" = "${BRANCH}"
     "org.opencontainers.image.description" = "${DESCRIPTION}"
     "org.opencontainers.image.licenses" = "BSD-3-Clause"
     "org.opencontainers.image.source" = "https://github.com/s-allius/tsun-gen3-proxy/ha_addonsha_addon"

ha_addons/ha_addon/Dockerfile

@@ -13,12 +13,12 @@
 # 1 Build Base Image #
 ######################
 
-ARG BUILD_FROM="ghcr.io/hassio-addons/base:18.0.3"
+ARG BUILD_FROM="ghcr.io/hassio-addons/base:17.2.5"
 # hadolint ignore=DL3006
 FROM $BUILD_FROM AS base
 
 # Installiere Python, pip und virtuelle Umgebungstools
-RUN apk add --no-cache python3=3.12.11-r0 py3-pip=25.1.1-r0 && \
+RUN apk add --no-cache python3=3.12.10-r1 py3-pip=24.3.1-r0 && \
     python -m venv /opt/venv && \
     . /opt/venv/bin/activate
 

ha_addons/ha_addon/rootfs/run.sh

@@ -4,10 +4,8 @@ bashio::log.blue "-----------------------------------------------------------"
 bashio::log.blue "run.sh: info: setup Add-on environment"
 bashio::cache.flush_all
 MQTT_HOST=""
-SLUG=""
-HOSTNAME=""
 if bashio::supervisor.ping; then
-    bashio::log "run.sh: info: check Home Assistant bashio for config values"
+    bashio::log "run.sh: info: check for Home Assistant MQTT service"
     if bashio::services.available mqtt; then
         MQTT_HOST=$(bashio::services mqtt "host")
         MQTT_PORT=$(bashio::services mqtt "port")
@@ -16,31 +14,15 @@ if bashio::supervisor.ping; then
     else
         bashio::log.yellow "run.sh: info: Home Assistant MQTT service not available!"
     fi
-    SLUG=$(bashio::addon.repository)
-    HOSTNAME=$(bashio::addon.hostname)
 else
     bashio::log.red "run.sh: error: Home Assistant Supervisor API not available!"
 fi
 
-if [ -z "$SLUG" ]; then
-    bashio::log.yellow "run.sh: info: addon slug not found"
-else
-    bashio::log.green "run.sh: info: found addon slug: $SLUG"
-    export SLUG
-
-fi
-if [ -z "$HOSTNAME" ]; then
-    bashio::log.yellow "run.sh: info: addon hostname not found"
-else
-    bashio::log.green "run.sh: info: found addon hostname: $HOSTNAME"
-    export HOSTNAME
-fi
-
 # if a MQTT was/not found, drop a note
 if [ -z "$MQTT_HOST" ]; then
     bashio::log.yellow "run.sh: info: MQTT config not found"
 else
-    bashio::log.green "run.sh: info: found MQTT config"
+    bashio::log.green "run.sh: info: MQTT config found"
     export MQTT_HOST
     export MQTT_PORT
     export MQTT_USER

ha_addons/templates/config.jinja

@@ -10,6 +10,8 @@ init: false
 arch:
   - aarch64
   - amd64
+  - armhf
+  - armv7
 startup: services
 homeassistant_api: true
 map: