Simplify event loop handling and remove deprecated get_event_loop

pyproject.toml

@@ -92,7 +92,14 @@ addopts = """
     """
 # https://iscinumpy.gitlab.io/post/bound-version-constraints/#watch-for-warnings
 # https://github.com/DiamondLightSource/FastCS/issues/230
-filterwarnings = "error"
+filterwarnings = [
+    "error",
+    # DeviceTestContext (pytango) leaks Unix IPC sockets and its internal asyncio
+    # event loop on some Python 3.11.x versions. These cannot be closed from
+    # Python because they are Tango C-level resources. Suppress rather than fail.
+    "ignore:unclosed <socket\\.socket:ResourceWarning",
+    "ignore:unclosed event loop:ResourceWarning",
+]
 # Doctest python code in docs, python code in src docstrings, test functions in tests
 testpaths = "docs src tests"
 timeout = 5

src/fastcs/control_system.py

@@ -32,11 +32,9 @@ def __init__(
         self,
         controller: Controller,
         transports: Sequence[Transport],
-        loop: asyncio.AbstractEventLoop | None = None,
     ):
         self._controller = controller
         self._transports = transports
-        self._loop = loop or asyncio.get_event_loop()
 
         self._scan_coros: list[ScanCallback] = []
         self._initial_coros: list[ScanCallback] = []
@@ -47,24 +45,20 @@ def run(self, interactive: bool = True):
         """Run the application
 
         This is a convenience method to call `serve` in a synchronous context.
+        To use in an async context, call `serve` directly.
 
         Args:
             interactive: Whether to create an interactive IPython shell
 
         """
-        serve = asyncio.ensure_future(self.serve(interactive=interactive))
-
-        if os.name != "nt":
-            self._loop.add_signal_handler(signal.SIGINT, serve.cancel)
-            self._loop.add_signal_handler(signal.SIGTERM, serve.cancel)
-        self._loop.run_until_complete(serve)
+        asyncio.run(self.serve(interactive=interactive))
 
     async def _run_initial_coros(self):
         for coro in self._initial_coros:
             await coro()
 
     async def _start_scan_tasks(self):
-        self._scan_tasks = {self._loop.create_task(coro()) for coro in self._scan_coros}
+        self._scan_tasks = {asyncio.create_task(coro()) for coro in self._scan_coros}
 
     def _stop_scan_tasks(self):
         for task in self._scan_tasks:
@@ -93,6 +87,13 @@ async def serve(self, interactive: bool = True) -> None:
             interactive: Whether to create an interactive IPython shell
 
         """
+        loop = asyncio.get_running_loop()
+        if os.name != "nt":
+            task = asyncio.current_task()
+            if task is not None:
+                loop.add_signal_handler(signal.SIGINT, task.cancel)
+                loop.add_signal_handler(signal.SIGTERM, task.cancel)
+
         await self._controller.initialise()
         self._controller.post_initialise()
 
@@ -110,7 +111,7 @@ async def serve(self, interactive: bool = True) -> None:
 
         coros: list[Coroutine] = []
         for transport in self._transports:
-            transport.connect(controller_api=self.controller_api, loop=self._loop)
+            transport.connect(controller_api=self.controller_api)
             coros.append(transport.serve())
             common_context = context.keys() & transport.context.keys()
             if common_context:
@@ -155,14 +156,15 @@ async def block_forever():
 
     async def _interactive_shell(self, context: dict[str, Any]):
         """Spawn interactive shell in another thread and wait for it to complete."""
+        loop = asyncio.get_running_loop()
 
         def run(coro: Coroutine[None, None, None]):
             """Run coroutine on FastCS event loop from IPython thread."""
 
             def wrapper():
                 asyncio.create_task(coro)
 
-            self._loop.call_soon_threadsafe(wrapper)
+            loop.call_soon_threadsafe(wrapper)
 
         async def interactive_shell(
             context: dict[str, object], stop_event: asyncio.Event
@@ -176,7 +178,7 @@ async def interactive_shell(
         context["run"] = run
 
         stop_event = asyncio.Event()
-        self._loop.create_task(interactive_shell(context, stop_event))
+        asyncio.create_task(interactive_shell(context, stop_event))
         await stop_event.wait()
 
     def __del__(self):

src/fastcs/launch.py

@@ -1,4 +1,3 @@
-import asyncio
 import inspect
 import json
 from pathlib import Path
@@ -158,9 +157,7 @@ def run(
         else:
             controller = controller_class()
 
-        instance = FastCS(
-            controller, instance_options.transport, loop=asyncio.get_event_loop()
-        )
+        instance = FastCS(controller, instance_options.transport)
 
         instance.run()
 

src/fastcs/transports/epics/ca/ioc.py

@@ -41,11 +41,8 @@ def __init__(
         _create_and_link_attribute_pvs(pv_prefix, controller_api)
         _create_and_link_command_pvs(pv_prefix, controller_api)
 
-    def run(
-        self,
-        loop: asyncio.AbstractEventLoop,
-    ) -> None:
-        dispatcher = AsyncioDispatcher(loop)  # Needs running loop
+    def run(self) -> None:
+        dispatcher = AsyncioDispatcher(asyncio.get_running_loop())
         builder.LoadDatabase()
         softioc.iocInit(dispatcher)
 

src/fastcs/transports/epics/ca/transport.py

@@ -1,4 +1,3 @@
-import asyncio
 from dataclasses import dataclass, field
 from typing import Any
 
@@ -28,13 +27,8 @@ class EpicsCATransport(Transport):
     gui: EpicsGUIOptions | None = None
     """Options for the GUI. If not set, no GUI will be created."""
 
-    def connect(
-        self,
-        controller_api: ControllerAPI,
-        loop: asyncio.AbstractEventLoop,
-    ) -> None:
+    def connect(self, controller_api: ControllerAPI) -> None:
         self._controller_api = controller_api
-        self._loop = loop
         self._pv_prefix = self.epicsca.pv_prefix
         self._ioc = EpicsCAIOC(self.epicsca.pv_prefix, controller_api)
 
@@ -47,7 +41,7 @@ def connect(
     async def serve(self) -> None:
         """Serve `ControllerAPI` over EPICS Channel Access"""
         logger.info("Running IOC", pv_prefix=self._pv_prefix)
-        self._ioc.run(self._loop)
+        self._ioc.run()
 
     @property
     def context(self) -> dict[str, Any]:

src/fastcs/transports/epics/pva/transport.py

@@ -1,13 +1,8 @@
-import asyncio
 from dataclasses import dataclass, field
 
 from fastcs.controllers import ControllerAPI
 from fastcs.logging import logger
-from fastcs.transports.epics import (
-    EpicsDocsOptions,
-    EpicsGUIOptions,
-    EpicsIOCOptions,
-)
+from fastcs.transports.epics import EpicsDocsOptions, EpicsGUIOptions, EpicsIOCOptions
 from fastcs.transports.epics.docs import EpicsDocs
 from fastcs.transports.epics.pva.gui import PvaEpicsGUI
 from fastcs.transports.transport import Transport
@@ -23,11 +18,7 @@ class EpicsPVATransport(Transport):
     docs: EpicsDocsOptions | None = None
     gui: EpicsGUIOptions | None = None
 
-    def connect(
-        self,
-        controller_api: ControllerAPI,
-        loop: asyncio.AbstractEventLoop,
-    ) -> None:
+    def connect(self, controller_api: ControllerAPI) -> None:
         self._controller_api = controller_api
         self._pv_prefix = self.epicspva.pv_prefix
         self._ioc = P4PIOC(self.epicspva.pv_prefix, controller_api)

src/fastcs/transports/graphql/transport.py

@@ -1,4 +1,3 @@
-import asyncio
 from dataclasses import dataclass, field
 
 from fastcs.controllers import ControllerAPI
@@ -14,11 +13,7 @@ class GraphQLTransport(Transport):
 
     graphql: GraphQLServerOptions = field(default_factory=GraphQLServerOptions)
 
-    def connect(
-        self,
-        controller_api: ControllerAPI,
-        loop: asyncio.AbstractEventLoop,
-    ):
+    def connect(self, controller_api: ControllerAPI):
         self._server = GraphQLServer(controller_api)
 
     async def serve(self) -> None:

src/fastcs/transports/rest/transport.py

@@ -1,4 +1,3 @@
-import asyncio
 from dataclasses import dataclass, field
 
 from fastcs.controllers import ControllerAPI
@@ -14,11 +13,7 @@ class RestTransport(Transport):
 
     rest: RestServerOptions = field(default_factory=RestServerOptions)
 
-    def connect(
-        self,
-        controller_api: ControllerAPI,
-        loop: asyncio.AbstractEventLoop,
-    ):
+    def connect(self, controller_api: ControllerAPI):
         self._server = RestServer(controller_api)
 
     async def serve(self) -> None:

src/fastcs/transports/tango/transport.py

@@ -13,13 +13,8 @@ class TangoTransport(Transport):
 
     tango: TangoDSROptions = field(default_factory=TangoDSROptions)
 
-    def connect(
-        self,
-        controller_api: ControllerAPI,
-        loop: asyncio.AbstractEventLoop,
-    ):
-        self._dsr = TangoDSR(controller_api, loop)
+    def connect(self, controller_api: ControllerAPI):
+        self._dsr = TangoDSR(controller_api, asyncio.get_running_loop())
 
     async def serve(self) -> None:
-        coro = asyncio.to_thread(self._dsr.run, self.tango)
-        await coro
+        await asyncio.to_thread(self._dsr.run, self.tango)

src/fastcs/transports/transport.py

@@ -1,4 +1,3 @@
-import asyncio
 from abc import abstractmethod
 from dataclasses import dataclass
 from typing import Any, ClassVar, Union
@@ -24,13 +23,12 @@ def union(cls):
         return Union[tuple(cls.subclasses)]  # noqa: UP007
 
     @abstractmethod
-    def connect(
-        self, controller_api: ControllerAPI, loop: asyncio.AbstractEventLoop
-    ) -> None:
+    def connect(self, controller_api: ControllerAPI) -> None:
         """Connect the ``Transport`` to the control system
 
-        The `ControllerAPI` should be exposed over the transport. The provided event
-        loop should be used where required instead of creating a new one.
+        The `ControllerAPI` should be exposed over the transport. Transports that
+        require the event loop should retrieve it with `asyncio.get_running_loop`,
+        as this method is called from within an async context.
 
         """
         pass

tests/benchmarking/controller.py

@@ -1,5 +1,3 @@
-import asyncio
-
 from fastcs import FastCS
 from fastcs.attributes import AttrR, AttrW
 from fastcs.controllers import Controller
@@ -25,7 +23,7 @@ def run():
         ),
         TangoTransport(tango=TangoDSROptions(dev_name="MY/BENCHMARK/DEVICE")),
     ]
-    instance = FastCS(MyTestController(), transport_options, asyncio.get_event_loop())
+    instance = FastCS(MyTestController(), transport_options)
     instance.run()
 
 

tests/test_control_system.py

@@ -13,9 +13,8 @@
 
 @pytest.mark.asyncio
 async def test_scan_tasks(controller):
-    loop = asyncio.get_event_loop()
     transport_options = []
-    fastcs = FastCS(controller, transport_options, loop)
+    fastcs = FastCS(controller, transport_options)
 
     asyncio.create_task(fastcs.serve(interactive=False))
     await asyncio.sleep(0.1)
@@ -43,9 +42,8 @@ async def do_nothing_static(self):
             pass
 
     controller = MyTestController()
-    loop = asyncio.get_event_loop()
     transport_options = []
-    fastcs = FastCS(controller, transport_options, loop)
+    fastcs = FastCS(controller, transport_options)
 
     asyncio.create_task(fastcs.serve(interactive=False))
     await asyncio.sleep(0.1)
@@ -79,9 +77,7 @@ class MyController(Controller):
         )
 
     controller = MyController(ios=[AttributeIOTimesCalled()])
-    loop = asyncio.get_event_loop()
-
-    fastcs = FastCS(controller, [], loop)
+    fastcs = FastCS(controller, [])
 
     assert controller.update_quickly.get() == 0
     assert controller.update_once.get() == 0
@@ -108,9 +104,7 @@ async def disconnect(self):
             self.connected = False
 
     controller = MyTestController()
-
-    loop = asyncio.get_event_loop()
-    fastcs = FastCS(controller, [], loop)
+    fastcs = FastCS(controller, [])
 
     task = asyncio.create_task(fastcs.serve(interactive=False))
 

tests/transports/epics/ca/test_initial_value.py

@@ -51,12 +51,10 @@ class InitialValuesController(Controller):
 async def test_initial_values_set_in_ca(mocker):
     pv_prefix = "SOFTIOC_INITIAL_DEVICE"
 
-    loop = asyncio.get_event_loop()
     controller = InitialValuesController()
     fastcs = FastCS(
         controller,
         [EpicsCATransport(epicsca=EpicsIOCOptions(pv_prefix=pv_prefix))],
-        loop,
     )
 
     record_spy = mocker.spy(ca_ioc, "_make_in_record")