migrate to new connect paradigm, omit all comlex runengine handling

Author: Peter Braun

src/secop_ophyd/SECoPDevices.py

@@ -2,7 +2,6 @@
 import inspect
 import logging
 import re
-import threading
 import time as ttime
 from logging import Logger
 from types import MethodType
@@ -32,7 +31,9 @@
     TupleOf,
 )
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
     AsyncStatus,
+    LazyMock,
     SignalR,
     SignalRW,
     SignalX,
@@ -839,8 +840,17 @@ class SECoPNodeDevice(StandardReadable):
     to the Sec-node properties
     """
 
+    name: str = ""
+
     def __init__(
-        self, secclient: AsyncFrappyClient, logger: Logger, logdir: str | None = None
+        self,
+        sec_node_uri: str,
+        # `prefix` not used, it's just that the device connecter requires it for
+        # some reason.
+        prefix: str = "",
+        name: str = "",
+        loglevel: str = "INFO",
+        logdir: str | None = None,
     ):
         """Initializes the node device and generates all node signals and subdevices
         corresponding to the SECoP-modules of the secnode
@@ -849,170 +859,98 @@ def __init__(
         :type secclient: AsyncFrappyClient
         """
 
-        self.equipment_id: SignalR
-        self.description: SignalR
-        self.version: SignalR
-
-        self._secclient: AsyncFrappyClient = secclient
-
-        self._module_name: str = ""
-        self._node_cls_name: str = ""
-        self.mod_devices: Dict[str, SECoPReadableDevice] = {}
-        self.node_prop_devices: Dict[str, SignalR] = {}
-
-        self.genCode: GenNodeCode
-
-        # Name is set to sec-node equipment_id
-        name = self._secclient.properties[EQUIPMENT_ID].replace(".", "-")
-
-        config = []
-
-        self.logger: Logger = logger
-
-        self.logger.info(
-            "Initializing SECoPNodeDevice "
-            + f"({self._secclient.host}:{self._secclient.port})"
-        )
-
-        with self.add_children_as_readables(
-            format=StandardReadableFormat.CONFIG_SIGNAL
-        ):
-            for property in self._secclient.properties:
-                propb = PropertyBackend(property, self._secclient.properties, secclient)
-                setattr(self, property, SignalR(backend=propb))
-                config.append(getattr(self, property))
-                self.node_prop_devices[property] = getattr(self, property)
-
-        with self.add_children_as_readables(format=StandardReadableFormat.CHILD):
-            for module, module_desc in self._secclient.modules.items():
+        self.host, self.port = sec_node_uri.rsplit(":", maxsplit=1)
 
-                secop_dev_class = self.class_from_interface(module_desc["properties"])
-
-                if secop_dev_class is not None:
-                    setattr(
-                        self,
-                        module,
-                        secop_dev_class(
-                            self._secclient,
-                            module,
-                            loglevel=self.logger.level,
-                            logdir=logdir,
-                        ),
-                    )
-                    self.mod_devices[module] = getattr(self, module)
-
-        # register secclient callbacks (these are useful if sec node description
-        # changes after a reconnect)
-        secclient.client.register_callback(
-            None, self.descriptiveDataChange, self.nodeStateChange
+        self.logger: Logger = setup_logging(
+            name=f"frappy:{self.host}:{self.port}",
+            level=LOG_LEVELS[loglevel],
+            log_dir=logdir,
         )
+        self.logdir = logdir
 
-        super().__init__(name=name)
-
-    @classmethod
-    def create(
-        cls,
-        host: str,
-        port: str,
-        loop,
-        loglevel: str = "INFO",
-        logdir: str | None = None,
-    ) -> "SECoPNodeDevice":
-
-        secclient: AsyncFrappyClient
-
-        logger: Logger = setup_logging(
-            name=f"frappy:{host}:{port}", level=LOG_LEVELS[loglevel], log_dir=logdir
-        )
+        self.name = name
 
-        if not loop.is_running():
-            raise Exception("The provided Eventloop is not running")
+    async def connect(
+        self,
+        mock: bool | LazyMock = False,
+        timeout: float = DEFAULT_TIMEOUT,
+        force_reconnect: bool = False,
+    ):
+        if not hasattr(self, "_secclient"):
+            secclient: AsyncFrappyClient
 
-        if loop._thread_id != threading.current_thread().ident:
-            client_future = asyncio.run_coroutine_threadsafe(
-                AsyncFrappyClient.create(host=host, port=port, loop=loop, log=logger),
-                loop,
+            secclient = await AsyncFrappyClient.create(
+                host=self.host,
+                port=self.port,
+                loop=asyncio.get_running_loop(),
+                log=self.logger,
             )
-            secclient = client_future.result()
 
-            secclient.external = True
+            self.equipment_id: SignalR
+            self.description: SignalR
+            self.version: SignalR
 
-        else:
-            raise Exception(
-                "should be calles with an eventloop that is"
-                "running in a seperate thread"
-            )
+            self._secclient: AsyncFrappyClient = secclient
 
-        return SECoPNodeDevice(secclient=secclient, logger=logger, logdir=logdir)
+            self._module_name: str = ""
+            self._node_cls_name: str = ""
+            self.mod_devices: Dict[str, SECoPReadableDevice] = {}
+            self.node_prop_devices: Dict[str, SignalR] = {}
 
-    @classmethod
-    async def create_async(
-        cls,
-        host: str,
-        port: str,
-        loop,
-        loglevel: str = "INFO",
-        logdir: str | None = None,
-    ) -> "SECoPNodeDevice":
+            self.genCode: GenNodeCode
 
-        logger: Logger = setup_logging(
-            name=f"frappy:{host}:{port}", level=LOG_LEVELS[loglevel], log_dir=logdir
-        )
+            if self.name == "":
+                self.name = self._secclient.properties[EQUIPMENT_ID].replace(".", "-")
 
-        secclient: AsyncFrappyClient
-
-        if not loop.is_running():
-            raise Exception("The provided Eventloop is not running")
+            config = []
 
-        if loop._thread_id == threading.current_thread().ident:
-            secclient = await AsyncFrappyClient.create(
-                host=host, port=port, loop=loop, log=logger
+            self.logger.info(
+                "Initializing SECoPNodeDevice "
+                + f"({self._secclient.host}:{self._secclient.port})"
             )
 
-            secclient.external = False
+            with self.add_children_as_readables(
+                format=StandardReadableFormat.CONFIG_SIGNAL
+            ):
+                for property in self._secclient.properties:
+                    propb = PropertyBackend(
+                        property, self._secclient.properties, secclient
+                    )
+                    setattr(self, property, SignalR(backend=propb))
+                    config.append(getattr(self, property))
+                    self.node_prop_devices[property] = getattr(self, property)
 
-        else:
-            # Event loop is running in a different thread
-            client_future = asyncio.run_coroutine_threadsafe(
-                AsyncFrappyClient.create(host=host, port=port, loop=loop, log=logger),
-                loop,
-            )
-            secclient = await asyncio.wrap_future(future=client_future)
-            secclient.external = True
+            with self.add_children_as_readables(format=StandardReadableFormat.CHILD):
+                for module, module_desc in self._secclient.modules.items():
 
-        return SECoPNodeDevice(secclient=secclient, logger=logger, logdir=logdir)
+                    secop_dev_class = self.class_from_interface(
+                        module_desc["properties"]
+                    )
 
-    def disconnect(self):
-        """shuts down secclient, eventloop must be running in external thread"""
-        if (
-            self._secclient.loop._thread_id == threading.current_thread().ident
-            and self._secclient.loop.is_running()
-        ):
-            raise Exception(
-                "Eventloop must be running in external thread,"
-                " try await node.disconnect_async()"
-            )
-        else:
-            future = asyncio.run_coroutine_threadsafe(
-                self._secclient.disconnect(True), self._secclient.loop
+                    if secop_dev_class is not None:
+                        setattr(
+                            self,
+                            module,
+                            secop_dev_class(
+                                self._secclient,
+                                module,
+                                loglevel=self.logger.level,
+                                logdir=self.logdir,
+                            ),
+                        )
+                        self.mod_devices[module] = getattr(self, module)
+
+            # register secclient callbacks (these are useful if sec node description
+            # changes after a reconnect)
+            secclient.client.register_callback(
+                None, self.descriptiveDataChange, self.nodeStateChange
             )
 
-            future.result(2)
+            super().__init__(name=self.name)
 
-    async def disconnect_async(self):
-        """shuts down secclient using asyncio, eventloop can be running in same or
-        external thread
-        """
-        if (
-            self._secclient.loop._thread_id == threading.current_thread().ident
-            and self._secclient.loop.is_running()
-        ):
+        elif force_reconnect or self._secclient.client.online is False:
             await self._secclient.disconnect(True)
-        else:
-            disconn_future = asyncio.run_coroutine_threadsafe(
-                self._secclient.disconnect(True), self._secclient.loop
-            )
-            await asyncio.wrap_future(future=disconn_future)
+            await self._secclient.connect(try_period=DEFAULT_TIMEOUT)
 
     def class_from_instance(self, path_to_module: str | None = None):
         """Dynamically generate python class file for the SECoP_Node_Device, this

tests/conftest.py

@@ -13,6 +13,7 @@
     StructOf,
     TupleOf,
 )
+from ophyd_async.core import init_devices
 from xprocess import ProcessStarter
 
 from secop_ophyd.AsyncFrappyClient import AsyncFrappyClient
@@ -151,38 +152,49 @@ async def nested_client(nested_struct_sim, logger, port="10771"):
 
 
 @pytest.fixture
-async def run_engine():
+async def RE():  # noqa: N802
     re = RunEngine({})
     return re
 
 
 @pytest.fixture
-async def cryo_node(run_engine):
-    return SECoPNodeDevice.create(
-        host="localhost", port="10769", loop=run_engine.loop, loglevel="INFO"
-    )
+async def nested_node_no_re():
+    async with init_devices():
+        nested = SECoPNodeDevice(
+            sec_node_uri="localhost:10771",
+        )
+
+    return nested
 
 
 @pytest.fixture
-def nested_node_re(run_engine):
-    return SECoPNodeDevice.create(host="localhost", port="10771", loop=run_engine.loop)
+def nested_node(RE):  # noqa: N803
+    with init_devices():
+        nested = SECoPNodeDevice(
+            sec_node_uri="localhost:10771",
+        )
+
+    return nested
 
 
 @pytest.fixture
-async def cryo_node_internal_loop():
-    return await SECoPNodeDevice.create_async(
-        host="localhost",
-        port="10769",
-        loop=asyncio.get_running_loop(),
-        loglevel="DEBUG",
-    )
+async def cryo_node_no_re():
+    async with init_devices():
+        cryo = SECoPNodeDevice(
+            sec_node_uri="localhost:10769",
+        )
+
+    return cryo
 
 
 @pytest.fixture
-async def nested_node():
-    return await SECoPNodeDevice.create_async(
-        host="localhost", port="10771", loop=asyncio.get_running_loop()
-    )
+def cryo_node(RE):  # noqa: N803
+    with init_devices():
+        cryo = SECoPNodeDevice(
+            sec_node_uri="localhost:10769",
+        )
+
+    return cryo
 
 
 @pytest.fixture

tests/test_ classgen.py

@@ -4,19 +4,15 @@
 from secop_ophyd.SECoPDevices import SECoPNodeDevice
 
 
-async def test_class_gen(nested_struct_sim, nested_node: SECoPNodeDevice):
-    nested_node.class_from_instance()
+async def test_class_gen(nested_struct_sim, nested_node_no_re: SECoPNodeDevice):
+    nested_node_no_re.class_from_instance()
 
     if os.path.exists("genNodeClass.py"):
         os.remove("genNodeClass.py")
 
-    await nested_node.disconnect_async()
 
-
-async def test_class_gen_path(nested_struct_sim, nested_node: SECoPNodeDevice):
-    nested_node.class_from_instance("tests")
+async def test_class_gen_path(nested_struct_sim, nested_node_no_re: SECoPNodeDevice):
+    nested_node_no_re.class_from_instance("tests")
 
     if os.path.exists("tests/genNodeClass.py"):
         os.remove("tests/genNodeClass.py")
-
-    await nested_node.disconnect_async()