added a callback to Attribute enabling backend to change values

For example, updating an attribute to have an `Int` with different units will make the epics backend update `EGU` of the corresponding record.

Author: evvaaaa

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
 
@@ -65,6 +66,10 @@ def __init__(
         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_callback: Callable[[DataType[T]], None] | None = None
+
     @property
     def datatype(self) -> DataType[T]:
         return self._datatype
@@ -85,6 +90,18 @@ def group(self) -> str | None:
     def allowed_values(self) -> list[T] | None:
         return self._allowed_values
 
+    def set_update_datatype_callback(
+        self, callback: Callable[[DataType[T]], None] | None
+    ) -> None:
+        self._update_datatype_callback = 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(datatype)}")
+        self._datatype = datatype
+        if self._update_datatype_callback is not None:
+            self._update_datatype_callback(datatype)
+
 
 class AttrR(Attribute[T]):
     """A read-only ``Attribute``."""

src/fastcs/backends/epics/ioc.py

@@ -1,10 +1,12 @@
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
 from types import MethodType
 from typing import Any, Literal
 
-from softioc import builder, softioc
+import numpy as np
+from softioc import builder, fields, softioc
 from softioc.asyncio_dispatcher import AsyncioDispatcher
+from softioc.imports import db_put_field
 from softioc.pythonSoftIoc import RecordWrapper
 
 from fastcs.attributes import AttrR, AttrRW, AttrW
@@ -17,7 +19,7 @@
     enum_value_to_index,
 )
 from fastcs.controller import BaseController
-from fastcs.datatypes import Bool, Float, Int, String, T
+from fastcs.datatypes import Bool, DataType, Float, Int, String, T
 from fastcs.exceptions import FastCSException
 from fastcs.mapping import Mapping
 
@@ -30,6 +32,35 @@ class EpicsIOCOptions:
     name_options: EpicsNameOptions = EpicsNameOptions()
 
 
+DATATYPE_NAME_TO_RECORD_FIELD = {
+    "prec": "PREC",
+    "units": "EGU",
+    "min": "DRVL",
+    "max": "DRVH",
+    "min_alarm": "LOPR",
+    "max_alarm": "HOPR",
+    "znam": "ZNAM",
+    "onam": "ONAM",
+}
+
+
+def datatype_to_epics_fields(datatype: DataType) -> dict[str, Any]:
+    return {
+        DATATYPE_NAME_TO_RECORD_FIELD[field]: value
+        for field, value in asdict(datatype).items()
+    }
+
+
+def reload_attribute_fields(pv: str, DataType: DataType):
+    """If the ioc side changes a field on the attribute
+    e.g ``units`` then this method will update it on the attribute"""
+
+    for name, value in datatype_to_epics_fields(DataType):
+        # TODO: can we just make every dtype a string and have the ioc convert?
+        array = np.require(value, dtype=np.dtype("S40"))
+        db_put_field(f"{pv}.{name}", fields.DBR_STRING, array, 1)
+
+
 class EpicsIOC:
     def __init__(
         self, pv_prefix: str, mapping: Mapping, options: EpicsIOCOptions | None = None
@@ -327,32 +358,32 @@ def _get_input_record(pv: str, attribute: AttrR) -> RecordWrapper:
         state_keys = dict(zip(MBB_STATE_FIELDS, attribute.allowed_values, strict=False))
         return builder.mbbIn(pv, **state_keys, **attribute_fields)
 
+    def datatype_updater(datatype: DataType):
+        reload_attribute_fields(pv, datatype)
+
+    attribute.set_update_datatype_callback(datatype_updater)
+
     match attribute.datatype:
-        case Bool(znam, onam):
-            return builder.boolIn(pv, ZNAM=znam, ONAM=onam, **attribute_fields)
-        case Int(units, min, max, min_alarm, max_alarm):
+        case Bool():
+            return builder.boolIn(
+                pv, **datatype_to_epics_fields(attribute.datatype), **attribute_fields
+            )
+        case Int():
             return builder.longIn(
                 pv,
-                EGU=units,
-                DRVL=min,
-                DRVH=max,
-                LOPR=min_alarm,
-                HOPR=max_alarm,
+                **datatype_to_epics_fields(attribute.datatype),
                 **attribute_fields,
             )
-        case Float(prec, units, min, max, min_alarm, max_alarm):
+        case Float():
             return builder.aIn(
                 pv,
-                PREC=prec,
-                EGU=units,
-                DRVL=min,
-                DRVH=max,
-                LOPR=min_alarm,
-                HOPR=max_alarm,
+                **datatype_to_epics_fields(attribute.datatype),
                 **attribute_fields,
             )
         case String():
-            return builder.longStringIn(pv, **attribute_fields)
+            return builder.longStringIn(
+                pv, **datatype_to_epics_fields(attribute.datatype), **attribute_fields
+            )
         case _:
             raise FastCSException(
                 f"Unsupported type {type(attribute.datatype)}: {attribute.datatype}"
@@ -376,38 +407,33 @@ def _get_output_record(pv: str, attribute: AttrW, on_update: Callable) -> Any:
             **attribute_fields,
         )
 
+    def datatype_updater(datatype: DataType):
+        reload_attribute_fields(pv, datatype)
+
+    attribute.set_update_datatype_callback(datatype_updater)
+
     match attribute.datatype:
-        case Bool(znam, onam):
+        case Bool():
             return builder.boolOut(
                 pv,
-                ZNAM=znam,
-                ONAM=onam,
+                **datatype_to_epics_fields(attribute.datatype),
                 always_update=True,
                 on_update=on_update,
             )
-        case Int(units, min, max, min_alarm, max_alarm):
+        case Int():
             return builder.longOut(
                 pv,
                 always_update=True,
                 on_update=on_update,
-                EGU=units,
-                DRVL=min,
-                DRVH=max,
-                LOPR=min_alarm,
-                HOPR=max_alarm,
+                **datatype_to_epics_fields(attribute.datatype),
                 **attribute_fields,
             )
-        case Float(prec, units, min, max, min_alarm, max_alarm):
+        case Float():
             return builder.aOut(
                 pv,
                 always_update=True,
                 on_update=on_update,
-                PREC=prec,
-                EGU=units,
-                DRVL=min,
-                DRVH=max,
-                LOPR=min_alarm,
-                HOPR=max_alarm,
+                **datatype_to_epics_fields(attribute.datatype),
                 **attribute_fields,
             )
         case String():

src/fastcs/datatypes.py

@@ -12,6 +12,7 @@
 AttrCallback = Callable[[T], Awaitable[None]]
 
 
+@dataclass(frozen=True)  # So that we can type hint with dataclass methods
 class DataType(Generic[T]):
     """Generic datatype mapping to a python type, with additional metadata."""