move StremPtr instances into Inverter class

app/src/gen3plus/connection_g3p.py

@@ -3,23 +3,19 @@ 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, StreamPtr
+    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, StreamPtr
+    from async_stream import AsyncStreamClient
+    from inverter import Inverter
     from gen3plus.solarman_v5 import SolarmanV5
 
 logger = logging.getLogger('conn')
 
 
 class ConnectionG3P(SolarmanV5):
-    async def async_create_remote(self) -> None:
-        pass  # virtual interface # pragma: no cover
-
-    async def async_publ_mqtt(self) -> None:
-        pass  # virtual interface # pragma: no cover
-
     def healthy(self) -> bool:
         logger.debug('ConnectionG3P healthy()')
         return self._ifc.healthy()
@@ -32,16 +28,15 @@ class ConnectionG3P(SolarmanV5):
 
 class ConnectionG3PServer(ConnectionG3P):
 
-    def __init__(self, reader: StreamReader, writer: StreamWriter,
-                 addr, rstream: 'ConnectionG3PClient',
-                 client_mode: bool) -> None:
+    def __init__(self, inverter: "Inverter",
+                 reader: StreamReader, writer: StreamWriter,
+                 addr, client_mode: bool) -> None:
 
         server_side = True
-        self.remote = StreamPtr(rstream)
         self._ifc = AsyncStreamServer(reader, writer,
-                                      self.async_publ_mqtt,
-                                      self.async_create_remote,
-                                      self.remote)
+                                      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)
@@ -49,13 +44,13 @@ class ConnectionG3PServer(ConnectionG3P):
 
 class ConnectionG3PClient(ConnectionG3P):
 
-    def __init__(self, reader: StreamReader, writer: StreamWriter,
-                 addr, rstream: 'ConnectionG3PServer') -> None:
+    def __init__(self, inverter: "Inverter",
+                 reader: StreamReader, writer: StreamWriter,
+                 addr) -> None:
 
         server_side = False
         client_mode = False
-        self.remote = StreamPtr(rstream)
-        self._ifc = AsyncStreamClient(reader, writer, self.remote)
+        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

@@ -3,10 +3,12 @@ from asyncio import StreamReader, StreamWriter
 
 if __name__ == "app.src.gen3plus.inverter_g3p":
     from app.src.inverter import Inverter
+    from app.src.async_stream import StreamPtr
     from app.src.gen3plus.connection_g3p import ConnectionG3PServer
     from app.src.gen3plus.connection_g3p import ConnectionG3PClient
 else:  # pragma: no cover
     from inverter import Inverter
+    from async_stream import StreamPtr
     from gen3plus.connection_g3p import ConnectionG3PServer
     from gen3plus.connection_g3p import ConnectionG3PClient
 
@@ -14,42 +16,15 @@ else:  # pragma: no cover
 logger_mqtt = logging.getLogger('mqtt')
 
 
-class InverterG3P(Inverter, ConnectionG3PServer):
-    '''class Inverter is a derivation of an Async_Stream
-
-    The class has some class method for managing common resources like a
-    connection to the MQTT broker or proxy error counter which are common
-    for all inverter connection
-
-    Instances of the class are connections to an inverter and can have an
-    optional link to an remote connection to the TSUN cloud. A remote
-    connection dies with the inverter connection.
-
-    class methods:
-        class_init():  initialize the common resources of the proxy (MQTT
-                       broker, Proxy DB, etc). Must be called before the
-                       first inverter instance can be created
-        class_close(): release the common resources of the proxy. Should not
-                       be called before any instances of the class are
-                       destroyed
-
-    methods:
-        server_loop(addr): Async loop method for receiving messages from the
-                           inverter (server-side)
-        client_loop(addr): Async loop method for receiving messages from the
-                           TSUN cloud (client-side)
-        async_create_remote(): Establish a client connection to the TSUN cloud
-        async_publ_mqtt(): Publish data to MQTT broker
-        close(): Release method which must be called before a instance can be
-                 destroyed
-    '''
-
+class InverterG3P(Inverter):
     def __init__(self, reader: StreamReader, writer: StreamWriter, addr,
                  client_mode: bool = False):
-        Inverter.__init__(self)
-        ConnectionG3PServer.__init__(
-            self, reader, writer, addr, None, client_mode=client_mode)
+        super().__init__()
         self.addr = addr
+        self.remote = StreamPtr(None)
+        self.local = StreamPtr(
+            ConnectionG3PServer(self, reader, writer, addr, client_mode)
+        )
 
     async def async_create_remote(self) -> None:
         await Inverter.async_create_remote(
@@ -57,5 +32,5 @@ class InverterG3P(Inverter, ConnectionG3PServer):
 
     def close(self) -> None:
         logging.debug(f'InverterG3P.close() {self.addr}')
-        ConnectionG3PServer.close(self)
+        self.local.stream.close()
 #        logger.debug (f'Inverter refs: {gc.get_referrers(self)}')