Mapping -> Controller

Author: marcelldls

src/fastcs/backend.py

@@ -7,9 +7,8 @@
 from fastcs.util import AsyncioDispatcher
 
 from .attributes import AttrR, AttrW, Sender, Updater
-from .controller import Controller
+from .controller import Controller, SingleMapping
 from .exceptions import FastCSException
-from .mapping import Mapping, SingleMapping
 
 
 class Backend:
@@ -29,17 +28,10 @@ def __init__(
             self._controller.initialise(), self._loop
         ).result()
 
-        self.mapping = Mapping(self._controller)
         self._link_process_tasks()
 
-        self.context = {
-            "dispatcher": self.dispatcher,
-            "controller": self._controller,
-            "mapping": self.mapping,
-        }
-
     def _link_process_tasks(self):
-        for single_mapping in self.mapping.get_controller_mappings():
+        for single_mapping in self._controller.get_controller_mappings():
             _link_single_controller_put_tasks(single_mapping)
             _link_attribute_sender_class(single_mapping)
 
@@ -58,7 +50,7 @@ def _run_initial_futures(self):
     def start_scan_futures(self):
         self._scan_futures = {
             asyncio.run_coroutine_threadsafe(coro(), self._loop)
-            for coro in _get_scan_coros(self.mapping)
+            for coro in _get_scan_coros(self._controller)
         }
 
     def stop_scan_futures(self):
@@ -106,10 +98,10 @@ async def callback(value):
     return callback
 
 
-def _get_scan_coros(mapping: Mapping) -> list[Callable]:
+def _get_scan_coros(controller: Controller) -> list[Callable]:
     scan_dict: dict[float, list[Callable]] = defaultdict(list)
 
-    for single_mapping in mapping.get_controller_mappings():
+    for single_mapping in controller.get_controller_mappings():
         _add_scan_method_tasks(scan_dict, single_mapping)
         _add_attribute_updater_tasks(scan_dict, single_mapping)
 

src/fastcs/controller.py

@@ -1,8 +1,21 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from copy import copy
+from dataclasses import dataclass
 
 from .attributes import Attribute
+from .cs_methods import Command, Put, Scan
+from .wrappers import WrappedMethod
+
+
+@dataclass
+class SingleMapping:
+    controller: BaseController
+    scan_methods: dict[str, Scan]
+    put_methods: dict[str, Put]
+    command_methods: dict[str, Command]
+    attributes: dict[str, Attribute]
 
 
 class BaseController:
@@ -42,6 +55,37 @@ def register_sub_controller(self, name: str, sub_controller: SubController):
     def get_sub_controllers(self) -> dict[str, BaseController]:
         return self.__sub_controller_tree
 
+    def get_controller_mappings(self) -> list[SingleMapping]:
+        return list(_walk_mappings(self))
+
+
+def _walk_mappings(controller: BaseController) -> Iterator[SingleMapping]:
+    yield _get_single_mapping(controller)
+    for sub_controller in controller.get_sub_controllers().values():
+        yield from _walk_mappings(sub_controller)
+
+
+def _get_single_mapping(controller: BaseController) -> SingleMapping:
+    scan_methods: dict[str, Scan] = {}
+    put_methods: dict[str, Put] = {}
+    command_methods: dict[str, Command] = {}
+    attributes: dict[str, Attribute] = {}
+    for attr_name in dir(controller):
+        attr = getattr(controller, attr_name)
+        match attr:
+            case WrappedMethod(fastcs_method=Put(enabled=True) as put_method):
+                put_methods[attr_name] = put_method
+            case WrappedMethod(fastcs_method=Scan(enabled=True) as scan_method):
+                scan_methods[attr_name] = scan_method
+            case WrappedMethod(fastcs_method=Command(enabled=True) as command_method):
+                command_methods[attr_name] = command_method
+            case Attribute(enabled=True):
+                attributes[attr_name] = attr
+
+    return SingleMapping(
+        controller, scan_methods, put_methods, command_methods, attributes
+    )
+
 
 class Controller(BaseController):
     """Top-level controller for a device.

src/fastcs/main.py

@@ -32,23 +32,22 @@ def __init__(
                 from .transport.epics.adapter import EpicsTransport
 
                 self._transport = EpicsTransport(
-                    self._backend.mapping,
-                    self._backend.context,
+                    controller,
                     self._backend.dispatcher,
                     transport_options,
                 )
             case TangoOptions():
                 from .transport.tango.adapter import TangoTransport
 
                 self._transport = TangoTransport(
-                    self._backend.mapping,
+                    controller,
                     transport_options,
                 )
             case RestOptions():
                 from .transport.rest.adapter import RestTransport
 
                 self._transport = RestTransport(
-                    self._backend.mapping,
+                    controller,
                     transport_options,
                 )
 

src/fastcs/mapping.py

@@ -2,7 +2,7 @@
 
 from softioc.asyncio_dispatcher import AsyncioDispatcher as Dispatcher
 
-from fastcs.mapping import Mapping
+from fastcs.controller import Controller
 from fastcs.transport.adapter import TransportAdapter
 from fastcs.util import AsyncioDispatcher
 
@@ -15,26 +15,23 @@
 class EpicsTransport(TransportAdapter):
     def __init__(
         self,
-        mapping: Mapping,
-        context: dict,
+        controller: Controller,
         dispatcher: AsyncioDispatcher,
         options: EpicsOptions | None = None,
     ) -> None:
         self.options = options or EpicsOptions()
-        self._mapping = mapping
-        self._context = context
+        self._controller = controller
         self._dispatcher = dispatcher
         self._pv_prefix = self.options.ioc.pv_prefix
-        self._ioc = EpicsIOC(self.options.ioc.pv_prefix, self._mapping)
+        self._ioc = EpicsIOC(self.options.ioc.pv_prefix, controller)
 
     def create_docs(self) -> None:
-        EpicsDocs(self._mapping).create_docs(self.options.docs)
+        EpicsDocs(self._controller).create_docs(self.options.docs)
 
     def create_gui(self) -> None:
-        EpicsGUI(self._mapping, self._pv_prefix).create_gui(self.options.gui)
+        EpicsGUI(self._controller, self._pv_prefix).create_gui(self.options.gui)
 
     def run(self):
         self._ioc.run(
             cast(Dispatcher, self._dispatcher),
-            self._context,
         )

src/fastcs/transport/epics/adapter.py

@@ -1,11 +1,11 @@
-from fastcs.mapping import Mapping
+from fastcs.controller import Controller
 
 from .options import EpicsDocsOptions
 
 
 class EpicsDocs:
-    def __init__(self, mapping: Mapping) -> None:
-        self._mapping = mapping
+    def __init__(self, controller: Controller) -> None:
+        self._controller = controller
 
     def create_docs(self, options: EpicsDocsOptions | None = None) -> None:
         if options is None:

src/fastcs/transport/epics/docs.py

@@ -23,18 +23,18 @@
 from pydantic import ValidationError
 
 from fastcs.attributes import Attribute, AttrR, AttrRW, AttrW
+from fastcs.controller import Controller, SingleMapping, _get_single_mapping
 from fastcs.cs_methods import Command
 from fastcs.datatypes import Bool, Float, Int, String
 from fastcs.exceptions import FastCSException
-from fastcs.mapping import Mapping, SingleMapping, _get_single_mapping
 from fastcs.util import snake_to_pascal
 
 from .options import EpicsGUIFormat, EpicsGUIOptions
 
 
 class EpicsGUI:
-    def __init__(self, mapping: Mapping, pv_prefix: str) -> None:
-        self._mapping = mapping
+    def __init__(self, controller: Controller, pv_prefix: str) -> None:
+        self._controller = controller
         self._pv_prefix = pv_prefix
 
     def _get_pv(self, attr_path: list[str], name: str):
@@ -117,7 +117,7 @@ def create_gui(self, options: EpicsGUIOptions | None = None) -> None:
 
         assert options.output_path.suffix == options.file_format.value
 
-        controller_mapping = self._mapping.get_controller_mappings()[0]
+        controller_mapping = self._controller.get_controller_mappings()[0]
         components = self.extract_mapping_components(controller_mapping)
         device = Device(label=options.title, children=components)
 

src/fastcs/transport/epics/gui.py

@@ -8,10 +8,9 @@
 from softioc.pythonSoftIoc import RecordWrapper
 
 from fastcs.attributes import AttrR, AttrRW, AttrW
-from fastcs.controller import BaseController
+from fastcs.controller import BaseController, Controller
 from fastcs.datatypes import Bool, DataType, Float, Int, String, T
 from fastcs.exceptions import FastCSException
-from fastcs.mapping import Mapping
 from fastcs.transport.epics.util import (
     MBB_STATE_FIELDS,
     attr_is_enum,
@@ -46,24 +45,31 @@ def datatype_to_epics_fields(datatype: DataType) -> dict[str, Any]:
 
 class EpicsIOC:
     def __init__(
-        self, pv_prefix: str, mapping: Mapping, options: EpicsIOCOptions | None = None
+        self,
+        pv_prefix: str,
+        controller: Controller,
+        options: EpicsIOCOptions | None = None,
     ):
         self.options = options or EpicsIOCOptions()
+        self._controller = controller
         _add_pvi_info(f"{pv_prefix}:PVI")
-        _add_sub_controller_pvi_info(pv_prefix, mapping.controller)
+        _add_sub_controller_pvi_info(pv_prefix, controller)
 
-        _create_and_link_attribute_pvs(pv_prefix, mapping)
-        _create_and_link_command_pvs(pv_prefix, mapping)
+        _create_and_link_attribute_pvs(pv_prefix, controller)
+        _create_and_link_command_pvs(pv_prefix, controller)
 
     def run(
         self,
         dispatcher: AsyncioDispatcher,
-        context: dict[str, Any],
     ) -> None:
         builder.LoadDatabase()
         softioc.iocInit(dispatcher)
 
         if self.options.terminal:
+            context = {
+                "dispatcher": dispatcher,
+                "controller": self._controller,
+            }
             softioc.interactive_ioc(context)
 
 
@@ -131,8 +137,8 @@ def _add_sub_controller_pvi_info(pv_prefix: str, parent: BaseController):
         _add_sub_controller_pvi_info(pv_prefix, child)
 
 
-def _create_and_link_attribute_pvs(pv_prefix: str, mapping: Mapping) -> None:
-    for single_mapping in mapping.get_controller_mappings():
+def _create_and_link_attribute_pvs(pv_prefix: str, controller: Controller) -> None:
+    for single_mapping in controller.get_controller_mappings():
         path = single_mapping.controller.path
         for attr_name, attribute in single_mapping.attributes.items():
             pv_name = attr_name.title().replace("_", "")
@@ -322,8 +328,8 @@ def datatype_updater(datatype: DataType):
     return record
 
 
-def _create_and_link_command_pvs(pv_prefix: str, mapping: Mapping) -> None:
-    for single_mapping in mapping.get_controller_mappings():
+def _create_and_link_command_pvs(pv_prefix: str, controller: Controller) -> None:
+    for single_mapping in controller.get_controller_mappings():
         path = single_mapping.controller.path
         for attr_name, method in single_mapping.command_methods.items():
             pv_name = attr_name.title().replace("_", "")

src/fastcs/transport/epics/ioc.py

@@ -1,4 +1,4 @@
-from fastcs.mapping import Mapping
+from fastcs.controller import Controller
 from fastcs.transport.adapter import TransportAdapter
 
 from .options import RestOptions
@@ -8,12 +8,11 @@
 class RestTransport(TransportAdapter):
     def __init__(
         self,
-        mapping: Mapping,
+        controller: Controller,
         options: RestOptions | None = None,
     ):
         self.options = options or RestOptions()
-        self._mapping = mapping
-        self._server = RestServer(self._mapping)
+        self._server = RestServer(controller)
 
     def create_docs(self) -> None:
         raise NotImplementedError