resolution of connection classes

- remove ConnectionG3Client
- remove ConnectionG3Server
- remove ConnectionG3PClient
- remove ConnectionG3PServer

app/src/gen3plus/connection_g3p.py

@@ -1,56 +1,18 @@
 import logging
-from asyncio import StreamReader, StreamWriter
 
 if __name__ == "app.src.gen3plus.connection_g3p":
-    from app.src.async_stream import AsyncStreamServer
-    from app.src.async_stream import AsyncStreamClient
-    from app.src.inverter import Inverter
     from app.src.gen3plus.solarman_v5 import SolarmanV5
 else:  # pragma: no cover
-    from async_stream import AsyncStreamServer
-    from async_stream import AsyncStreamClient
-    from inverter import Inverter
     from gen3plus.solarman_v5 import SolarmanV5
 
 logger = logging.getLogger('conn')
 
 
 class ConnectionG3P(SolarmanV5):
-    def healthy(self) -> bool:
-        logger.debug('ConnectionG3P healthy()')
-        return self._ifc.healthy()
+    def __init__(self, addr, ifc, server_side,
+                 client_mode: bool = False) -> None:
+        super().__init__(addr, server_side, client_mode, ifc)
 
     def close(self):
-        self._ifc.close()
-        SolarmanV5.close(self)
+        super().close()
         #  logger.info(f'AsyncStream refs: {gc.get_referrers(self)}')
-
-
-class ConnectionG3PServer(ConnectionG3P):
-
-    def __init__(self, inverter: "Inverter",
-                 reader: StreamReader, writer: StreamWriter,
-                 addr, client_mode: bool) -> None:
-
-        server_side = True
-        self._ifc = AsyncStreamServer(reader, writer,
-                                      inverter.async_publ_mqtt,
-                                      inverter.async_create_remote,
-                                      inverter.remote)
-        self.conn_no = self._ifc.get_conn_no()
-        self.addr = addr
-        SolarmanV5.__init__(self, server_side, client_mode, self._ifc)
-
-
-class ConnectionG3PClient(ConnectionG3P):
-
-    def __init__(self, inverter: "Inverter",
-                 reader: StreamReader, writer: StreamWriter,
-                 addr) -> None:
-
-        server_side = False
-        client_mode = False
-        self._ifc = AsyncStreamClient(reader, writer, inverter.remote)
-        self.conn_no = self._ifc.get_conn_no()
-        self.addr = addr
-        SolarmanV5.__init__(self, server_side, client_mode, self._ifc)

app/src/gen3plus/inverter_g3p.py

@@ -2,33 +2,38 @@ import logging
 from asyncio import StreamReader, StreamWriter
 
 if __name__ == "app.src.gen3plus.inverter_g3p":
-    from app.src.inverter import Inverter
+    from app.src.inverter_base import InverterBase
     from app.src.async_stream import StreamPtr
-    from app.src.gen3plus.connection_g3p import ConnectionG3PServer
-    from app.src.gen3plus.connection_g3p import ConnectionG3PClient
+    from app.src.async_stream import AsyncStreamServer
+    from app.src.gen3plus.connection_g3p import ConnectionG3P
 else:  # pragma: no cover
-    from inverter import Inverter
+    from inverter_base import InverterBase
     from async_stream import StreamPtr
-    from gen3plus.connection_g3p import ConnectionG3PServer
-    from gen3plus.connection_g3p import ConnectionG3PClient
+    from async_stream import AsyncStreamServer
+    from gen3plus.connection_g3p import ConnectionG3P
 
 
 logger_mqtt = logging.getLogger('mqtt')
 
 
-class InverterG3P(Inverter):
+class InverterG3P(InverterBase):
     def __init__(self, reader: StreamReader, writer: StreamWriter, addr,
                  client_mode: bool = False):
         super().__init__()
         self.addr = addr
         self.remote = StreamPtr(None)
+        ifc = AsyncStreamServer(reader, writer,
+                                self.async_publ_mqtt,
+                                self.async_create_remote,
+                                self.remote)
+
         self.local = StreamPtr(
-            ConnectionG3PServer(self, reader, writer, addr, client_mode)
+            ConnectionG3P(addr, ifc, True, client_mode)
         )
 
     async def async_create_remote(self) -> None:
-        await Inverter.async_create_remote(
-            self, 'solarman', ConnectionG3PClient)
+        await InverterBase.async_create_remote(
+            self, 'solarman', ConnectionG3P)
 
     def close(self) -> None:
         logging.debug(f'InverterG3P.close() {self.addr}')

app/src/gen3plus/solarman_v5.py

@@ -62,14 +62,17 @@ class SolarmanV5(Message):
     HDR_FMT = '<BLLL'
     '''format string for packing of the header'''
 
-    def __init__(self, server_side: bool, client_mode: bool, ifc: "AsyncIfc"):
+    def __init__(self, addr, server_side: bool, client_mode: bool,
+                 ifc: "AsyncIfc"):
         super().__init__(server_side, self.send_modbus_cb, mb_timeout=8)
         ifc.rx_set_cb(self.read)
         ifc.prot_set_timeout_cb(self._timeout)
         ifc.prot_set_init_new_client_conn_cb(self._init_new_client_conn)
         ifc.prot_set_update_header_cb(self._update_header)
 
+        self.addr = addr
         self.ifc = ifc
+        self.conn_no = ifc.get_conn_no()
         self.header_len = 11  # overwrite construcor in class Message
         self.control = 0
         self.seq = Sequence(server_side)
@@ -150,6 +153,10 @@ class SolarmanV5(Message):
     '''
     Our puplic methods
     '''
+    def healthy(self) -> bool:
+        logger.debug('SolarmanV5 healthy()')
+        return self.ifc.healthy()
+
     def close(self) -> None:
         logging.debug('Solarman.close()')
         if self.server_side:
@@ -167,6 +174,7 @@ class SolarmanV5(Message):
         self.log_lvl.clear()
         self.state = State.closed
         self.mb_timer.close()
+        self.ifc.close()
         self.ifc.rx_set_cb(None)
         self.ifc.prot_set_timeout_cb(None)
         self.ifc.prot_set_init_new_client_conn_cb(None)