Merge branch 'main' into rest-backend

Author: marcelldls

pyproject.toml

@@ -17,7 +17,7 @@ dependencies = [
     "pydantic",
     "pvi~=0.10.0",
     "pytango",
-    "softioc",
+    "softioc>=4.5.0",
 ]
 dynamic = ["version"]
 license.file = "LICENSE"

src/fastcs/attributes.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from enum import Enum
 from typing import Any, Generic, Protocol, runtime_checkable
 
@@ -26,7 +27,8 @@ async def put(self, controller: Any, attr: AttrW, value: Any) -> None:
 class Updater(Protocol):
     """Protocol for updating the cached readback value of an ``Attribute``."""
 
-    update_period: float
+    # If update period is None then the attribute will not be updated as a task.
+    update_period: float | None = None
 
     async def update(self, controller: Any, attr: AttrR) -> None:
         pass
@@ -52,6 +54,7 @@ def __init__(
         group: str | None = None,
         handler: Any = None,
         allowed_values: list[T] | None = None,
+        description: str | None = None,
     ) -> None:
         assert (
             datatype.dtype in ATTRIBUTE_TYPES
@@ -61,6 +64,11 @@ def __init__(
         self._group = group
         self.enabled = True
         self._allowed_values: list[T] | None = allowed_values
+        self.description = description
+
+        # A callback to use when setting the datatype to a different value, for example
+        # changing the units on an int. This should be implemented in the backend.
+        self._update_datatype_callbacks: list[Callable[[DataType[T]], None]] = []
 
     @property
     def datatype(self) -> DataType[T]:
@@ -82,6 +90,20 @@ def group(self) -> str | None:
     def allowed_values(self) -> list[T] | None:
         return self._allowed_values
 
+    def add_update_datatype_callback(
+        self, callback: Callable[[DataType[T]], None]
+    ) -> None:
+        self._update_datatype_callbacks.append(callback)
+
+    def update_datatype(self, datatype: DataType[T]) -> None:
+        if not isinstance(self._datatype, type(datatype)):
+            raise ValueError(
+                f"Attribute datatype must be of type {type(self._datatype)}"
+            )
+        self._datatype = datatype
+        for callback in self._update_datatype_callbacks:
+            callback(datatype)
+
 
 class AttrR(Attribute[T]):
     """A read-only ``Attribute``."""
@@ -92,24 +114,29 @@ def __init__(
         access_mode=AttrMode.READ,
         group: str | None = None,
         handler: Updater | None = None,
+        initial_value: T | None = None,
         allowed_values: list[T] | None = None,
+        description: str | None = None,
     ) -> None:
         super().__init__(
             datatype,  # type: ignore
             access_mode,
             group,
             handler,
             allowed_values=allowed_values,  # type: ignore
+            description=description,
+        )
+        self._value: T = (
+            datatype.initial_value if initial_value is None else initial_value
         )
-        self._value: T = datatype.dtype()
         self._update_callback: AttrCallback[T] | None = None
         self._updater = handler
 
     def get(self) -> T:
         return self._value
 
     async def set(self, value: T) -> None:
-        self._value = self._datatype.dtype(value)
+        self._value = self._datatype.validate(value)
 
         if self._update_callback is not None:
             await self._update_callback(self._value)
@@ -132,13 +159,15 @@ def __init__(
         group: str | None = None,
         handler: Sender | None = None,
         allowed_values: list[T] | None = None,
+        description: str | None = None,
     ) -> None:
         super().__init__(
             datatype,  # type: ignore
             access_mode,
             group,
             handler,
             allowed_values=allowed_values,  # type: ignore
+            description=description,
         )
         self._process_callback: AttrCallback[T] | None = None
         self._write_display_callback: AttrCallback[T] | None = None
@@ -150,11 +179,11 @@ async def process(self, value: T) -> None:
 
     async def process_without_display_update(self, value: T) -> None:
         if self._process_callback is not None:
-            await self._process_callback(self._datatype.dtype(value))
+            await self._process_callback(self._datatype.validate(value))
 
     async def update_display_without_process(self, value: T) -> None:
         if self._write_display_callback is not None:
-            await self._write_display_callback(self._datatype.dtype(value))
+            await self._write_display_callback(self._datatype.validate(value))
 
     def set_process_callback(self, callback: AttrCallback[T] | None) -> None:
         self._process_callback = callback
@@ -170,7 +199,7 @@ def sender(self) -> Sender | None:
         return self._sender
 
 
-class AttrRW(AttrW[T], AttrR[T]):
+class AttrRW(AttrR[T], AttrW[T]):
     """A read-write ``Attribute``."""
 
     def __init__(
@@ -179,14 +208,18 @@ def __init__(
         access_mode=AttrMode.READ_WRITE,
         group: str | None = None,
         handler: Handler | None = None,
+        initial_value: T | None = None,
         allowed_values: list[T] | None = None,
+        description: str | None = None,
     ) -> None:
         super().__init__(
             datatype,  # type: ignore
             access_mode,
-            group,
-            handler,
-            allowed_values,  # type: ignore
+            group=group,
+            handler=handler,
+            initial_value=initial_value,
+            allowed_values=allowed_values,  # type: ignore
+            description=description,
         )
 
     async def process(self, value: T) -> None:

src/fastcs/backend.py

@@ -20,8 +20,8 @@ def __init__(
         self._loop = self._dispatcher.loop
         self._controller = controller
 
-        self._initial_tasks = [controller.connect]
-        self._scan_tasks: list[Future] = []
+        self._initial_coros = [controller.connect]
+        self._scan_futures: set[Future] = set()
 
         asyncio.run_coroutine_threadsafe(
             self._controller.initialise(), self._loop
@@ -41,22 +41,32 @@ def _link_process_tasks(self):
             _link_single_controller_put_tasks(single_mapping)
             _link_attribute_sender_class(single_mapping)
 
-    def run(self):
-        self._run_initial_tasks()
-        self._start_scan_tasks()
+    def __del__(self):
+        self.stop_scan_futures()
 
+    def run(self):
+        self._run_initial_futures()
+        self.start_scan_futures()
         self._run()
 
-    def _run_initial_tasks(self):
-        for task in self._initial_tasks:
-            future = asyncio.run_coroutine_threadsafe(task(), self._loop)
+    def _run_initial_futures(self):
+        for coro in self._initial_coros:
+            future = asyncio.run_coroutine_threadsafe(coro(), self._loop)
             future.result()
 
-    def _start_scan_tasks(self):
-        scan_tasks = _get_scan_tasks(self._mapping)
+    def start_scan_futures(self):
+        self._scan_futures = {
+            asyncio.run_coroutine_threadsafe(coro(), self._loop)
+            for coro in _get_scan_coros(self._mapping)
+        }
 
-        for task in scan_tasks:
-            asyncio.run_coroutine_threadsafe(task(), self._loop)
+    def stop_scan_futures(self):
+        for future in self._scan_futures:
+            if not future.done():
+                try:
+                    future.cancel()
+                except asyncio.CancelledError:
+                    pass
 
     def _run(self):
         raise NotImplementedError("Specific Backend must implement _run")
@@ -98,15 +108,15 @@ async def callback(value):
     return callback
 
 
-def _get_scan_tasks(mapping: Mapping) -> list[Callable]:
+def _get_scan_coros(mapping: Mapping) -> list[Callable]:
     scan_dict: dict[float, list[Callable]] = defaultdict(list)
 
     for single_mapping in mapping.get_controller_mappings():
         _add_scan_method_tasks(scan_dict, single_mapping)
         _add_attribute_updater_tasks(scan_dict, single_mapping)
 
-    scan_tasks = _get_periodic_scan_tasks(scan_dict)
-    return scan_tasks
+    scan_coros = _get_periodic_scan_coros(scan_dict)
+    return scan_coros
 
 
 def _add_scan_method_tasks(
@@ -127,7 +137,8 @@ def _add_attribute_updater_tasks(
                 callback = _create_updater_callback(
                     attribute, single_mapping.controller
                 )
-                scan_dict[update_period].append(callback)
+                if update_period is not None:
+                    scan_dict[update_period].append(callback)
 
 
 def _create_updater_callback(attribute, controller):
@@ -144,18 +155,18 @@ async def callback():
     return callback
 
 
-def _get_periodic_scan_tasks(scan_dict: dict[float, list[Callable]]) -> list[Callable]:
-    periodic_scan_tasks: list[Callable] = []
+def _get_periodic_scan_coros(scan_dict: dict[float, list[Callable]]) -> list[Callable]:
+    periodic_scan_coros: list[Callable] = []
     for period, methods in scan_dict.items():
-        periodic_scan_tasks.append(_create_periodic_scan_task(period, methods))
+        periodic_scan_coros.append(_create_periodic_scan_coro(period, methods))
 
-    return periodic_scan_tasks
+    return periodic_scan_coros
 
 
-def _create_periodic_scan_task(period, methods: list[Callable]) -> Callable:
-    async def scan_task() -> None:
+def _create_periodic_scan_coro(period, methods: list[Callable]) -> Callable:
+    async def scan_coro() -> None:
         while True:
             await asyncio.gather(*[method() for method in methods])
             await asyncio.sleep(period)
 
-    return scan_task
+    return scan_coro

src/fastcs/backends/epics/backend.py

@@ -7,17 +7,22 @@
 
 
 class EpicsBackend(Backend):
-    def __init__(self, controller: Controller, pv_prefix: str = "MY-DEVICE-PREFIX"):
+    def __init__(
+        self,
+        controller: Controller,
+        pv_prefix: str = "MY-DEVICE-PREFIX",
+        options: EpicsIOCOptions | None = None,
+    ):
         super().__init__(controller)
 
         self._pv_prefix = pv_prefix
-        self._ioc = EpicsIOC(pv_prefix, self._mapping)
+        self._ioc = EpicsIOC(pv_prefix, self._mapping, options=options)
 
     def create_docs(self, options: EpicsDocsOptions | None = None) -> None:
         EpicsDocs(self._mapping).create_docs(options)
 
     def create_gui(self, options: EpicsGUIOptions | None = None) -> None:
         EpicsGUI(self._mapping, self._pv_prefix).create_gui(options)
 
-    def _run(self, options: EpicsIOCOptions | None = None):
-        self._ioc.run(self._dispatcher, self._context, options)
+    def _run(self):
+        self._ioc.run(self._dispatcher, self._context)