Composition > Inheritance

Author: marcelldls

src/fastcs/backend.py

@@ -1,5 +1,4 @@
 import asyncio
-from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import Callable
 from concurrent.futures import Future
@@ -13,12 +12,14 @@
 from .mapping import Mapping, SingleMapping
 
 
-class Backend(ABC):
+class Backend:
     def __init__(
-        self, controller: Controller, loop: asyncio.AbstractEventLoop | None = None
+        self,
+        controller: Controller,
+        loop: asyncio.AbstractEventLoop | None = None,
     ):
-        self._dispatcher = AsyncioDispatcher(loop)
-        self._loop = self._dispatcher.loop
+        self.dispatcher = AsyncioDispatcher(loop)
+        self._loop = self.dispatcher.loop
         self._controller = controller
 
         self._initial_tasks = [controller.connect]
@@ -28,55 +29,35 @@ def __init__(
             self._controller.initialise(), self._loop
         ).result()
 
-        self._mapping = Mapping(self._controller)
+        self.mapping = Mapping(self._controller)
         self._link_process_tasks()
 
-        self._context = {
-            "dispatcher": self._dispatcher,
+        self.context = {
+            "dispatcher": self.dispatcher,
             "controller": self._controller,
-            "mapping": self._mapping,
+            "mapping": self.mapping,
         }
 
     def _link_process_tasks(self):
-        for single_mapping in self._mapping.get_controller_mappings():
+        for single_mapping in self.mapping.get_controller_mappings():
             _link_single_controller_put_tasks(single_mapping)
             _link_attribute_sender_class(single_mapping)
 
     def run(self):
         self._run_initial_tasks()
         self._start_scan_tasks()
 
-        self._run()
-
-    def create_docs(self) -> None:
-        self._create_docs()
-
-    def create_gui(self) -> None:
-        self._create_gui()
-
     def _run_initial_tasks(self):
         for task in self._initial_tasks:
             future = asyncio.run_coroutine_threadsafe(task(), self._loop)
             future.result()
 
     def _start_scan_tasks(self):
-        scan_tasks = _get_scan_tasks(self._mapping)
+        scan_tasks = _get_scan_tasks(self.mapping)
 
         for task in scan_tasks:
             asyncio.run_coroutine_threadsafe(task(), self._loop)
 
-    @abstractmethod
-    def _run(self) -> None:
-        pass
-
-    @abstractmethod
-    def _create_docs(self) -> None:
-        pass
-
-    @abstractmethod
-    def _create_gui(self) -> None:
-        pass
-
 
 def _link_single_controller_put_tasks(single_mapping: SingleMapping) -> None:
     for name, method in single_mapping.put_methods.items():

src/fastcs/backends/asyncio_backend.py

@@ -1,27 +1,51 @@
+from dataclasses import dataclass
+from typing import Any
+
 from .backend import Backend
-from .backends.epics.options import EpicsOptions
-from .backends.tango.options import TangoOptions
 from .controller import Controller
+from .transport.adapter import TransportAdapter
+from .transport.epics.options import EpicsOptions
+from .transport.tango.options import TangoOptions
 
 
-class FastCS:
-    def __init__(self, controller: Controller, options: EpicsOptions | TangoOptions):
-        self.backend: Backend
-        match options:
-            case EpicsOptions():
-                from .backends.epics.backend import EpicsBackend
+@dataclass
+class FastCSOptions:
+    transport: EpicsOptions | TangoOptions
+    controller: Any = None
+
 
-                self.backend = EpicsBackend(controller, options)
+class FastCS:
+    def __init__(
+        self,
+        controller: Controller,
+        options: FastCSOptions,
+    ):
+        self.backend = Backend(controller)
+        self.transport: TransportAdapter
+        match options.transport:
             case TangoOptions():
-                from .backends.tango.backend import TangoBackend
+                from .transport.tango.adapter import TangoTransport
+
+                self.transport = TangoTransport(
+                    self.backend.mapping,
+                    options.transport,
+                )
+            case EpicsOptions():
+                from .transport.epics.adapter import EpicsTransport
 
-                self.backend = TangoBackend(controller, options)
+                self.transport = EpicsTransport(
+                    self.backend.mapping,
+                    self.backend.context,
+                    self.backend.dispatcher,
+                    options.transport,
+                )
 
     def create_docs(self) -> None:
-        self.backend.create_docs()
+        self.transport.create_docs()
 
     def create_gui(self) -> None:
-        self.backend.create_gui()
+        self.transport.create_gui()
 
     def run(self) -> None:
         self.backend.run()
+        self.transport.run()

src/fastcs/backends/epics/backend.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass
+class TransportOptions:
+    pass
+
+
+class TransportAdapter(ABC):
+    @abstractmethod
+    def run(self) -> None:
+        pass
+
+    @abstractmethod
+    def create_docs(self) -> None:
+        pass
+
+    @abstractmethod
+    def create_gui(self) -> None:
+        pass

src/fastcs/backends/tango/backend.py

@@ -0,0 +1,43 @@
+from typing import cast
+
+from softioc.asyncio_dispatcher import AsyncioDispatcher as Dispatcher
+
+from fastcs.mapping import Mapping
+from fastcs.transport.adapter import TransportAdapter
+from fastcs.util import AsyncioDispatcher
+
+from .docs import EpicsDocs
+from .gui import EpicsGUI
+from .ioc import EpicsIOC
+from .options import EpicsOptions
+
+
+class EpicsTransport(TransportAdapter):
+    def __init__(
+        self,
+        mapping: Mapping,
+        context: dict,
+        dispatcher: AsyncioDispatcher,
+        options: EpicsOptions | None = None,
+    ) -> None:
+        if options is None:
+            self.options = EpicsOptions()
+        else:
+            self.options = options
+
+        self._mapping = mapping
+        self._context = context
+        self._dispatcher = dispatcher
+        self._pv_prefix = self.options.ioc.pv_prefix
+        self._ioc = EpicsIOC(self.options.ioc.pv_prefix, self._mapping)
+
+    def create_docs(self) -> None:
+        EpicsDocs(self._mapping).create_docs(self.options.docs)
+
+    def create_gui(self) -> None:
+        EpicsGUI(self._mapping, self._pv_prefix).create_gui(self.options.gui)
+
+    def run(self):
+        self._ioc.run(
+            cast(Dispatcher, self._dispatcher), self._context, self.options.ioc
+        )