added WaveForm type

Author: evvaaaa

src/fastcs/attributes.py

@@ -4,7 +4,7 @@
 from enum import Enum
 from typing import Any, Generic, Protocol, runtime_checkable
 
-from .datatypes import ATTRIBUTE_TYPES, AttrCallback, DataType, T, validate_value
+from .datatypes import ATTRIBUTE_TYPES, AttrCallback, DataType, T
 
 
 class AttrMode(Enum):
@@ -124,15 +124,17 @@ def __init__(
             allowed_values=allowed_values,  # type: ignore
             description=description,
         )
-        self._value: T = datatype.dtype() if initial_value is None else initial_value
+        self._value: T = (
+            datatype.initial_value if initial_value is None else initial_value
+        )
         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(validate_value(self._datatype, value))
+        self._value = self._datatype.cast(value)
 
         if self._update_callback is not None:
             await self._update_callback(self._value)
@@ -175,11 +177,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.cast(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.cast(value))
 
     def set_process_callback(self, callback: AttrCallback[T] | None) -> None:
         self._process_callback = callback
@@ -219,6 +221,6 @@ def __init__(
         )
 
     async def process(self, value: T) -> None:
-        await self.set(validate_value(self._datatype, value))
+        await self.set(value)
 
         await super().process(value)  # type: ignore

src/fastcs/backends/epics/ioc.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 from dataclasses import asdict, dataclass
 from types import MethodType
-from typing import Any, Literal, cast
+from typing import Any, Literal
 
 import numpy as np
 from softioc import builder, fields, softioc
@@ -18,9 +18,8 @@
     enum_index_to_value,
     enum_value_to_index,
 )
-from epicsdbbuilder import RecordName
 from fastcs.controller import BaseController
-from fastcs.datatypes import Bool, DataType, Float, Int, String, T, Table, WaveForm
+from fastcs.datatypes import Bool, DataType, Float, Int, String, T, WaveForm
 from fastcs.exceptions import FastCSException
 from fastcs.mapping import Mapping
 
@@ -302,114 +301,6 @@ def _add_attr_pvi_info(
             },
         )
 
-    def create_table(self, top_level_pv: str, datatype: np.dtype):
-        pva_table_name = RecordName(top_level_pv)
-
-        columns = datatype.descr
-        if not columns or not all(
-            isinstance(column, tuple) and len(column) == 2 for column in columns
-        ):
-            raise FastCSException("Table datatype must have a structured dtype.")
-
-        columns = cast(list[tuple[str, np.dtype]], columns)
-
-        labels_record: RecordWrapper = builder.WaveformOut(
-            top_level_pv + ":LABELS",
-            initial_value=np.array([name.encode() for (name, _) in columns]),
-        )
-
-        labels_record.add_info(
-            "Q:group",
-            {
-                pva_table_name: {
-                    "+id": "epics:nt/NTTable:1.0",
-                    "labels": {"+type": "plain", "+channel": "VAL"},
-                }
-            },
-        )
-
-        pv_rec = builder.longStringIn(
-            top_level_pv + ":PV",
-            initial_value=pva_table_name,
-        )
-        block, field = top_level_pv.rsplit(":", maxsplit=1)
-        _add_pvi_info(field, block, field.lower())
-
-        self.table_fields_records = OrderedDict(
-            {
-                k: TableFieldRecordContainer(v, None)
-                for k, v in field_info.fields.items()
-            }
-        )
-        self.all_values_dict = all_values_dict
-
-        pvi_table_name = epics_to_pvi_name(table_name)
-
-        # The PVI group to put all records into
-        pvi_group = PviGroup.PARAMETERS
-        Pvi.add_pvi_info(
-            table_name,
-            pvi_group,
-            SignalRW(
-                name=pvi_table_name,
-                write_pv=f"{Pvi.record_prefix}:{table_name}",
-                write_widget=TableWrite(widgets=[]),
-            ),
-        )
-
-        # Note that the table_updater's table_fields are guaranteed sorted in bit order,
-        # unlike field_info's fields. This means the record dict inside the table
-        # updater are also in the same bit order.
-        value = all_values_dict[table_name]
-        assert isinstance(value, list)
-        field_data = words_to_table(value, field_info)
-
-        for i, (field_name, field_record_container) in enumerate(
-            self.table_fields_records.items()
-        ):
-            field_details = field_record_container.field
-
-            full_name = table_name + ":" + field_name
-            full_name = EpicsName(full_name)
-            description = trim_description(field_details.description, full_name)
-
-            waveform_val = self._construct_waveform_val(
-                field_data, field_name, field_details
-            )
-
-            field_record: RecordWrapper = builder.WaveformOut(
-                full_name,
-                DESC=description,
-                validate=self.validate_waveform,
-                initial_value=waveform_val,
-                length=field_info.max_length,
-            )
-
-            field_pva_info = {
-                "+type": "plain",
-                "+channel": "VAL",
-                "+putorder": i + 1,
-                "+trigger": "",
-            }
-
-            pva_info = {f"value.{field_name.lower()}": field_pva_info}
-
-            # For the last column in the table
-            if i == len(self.table_fields_records) - 1:
-                # Trigger a monitor update
-                field_pva_info["+trigger"] = "*"
-                # Add metadata
-                pva_info[""] = {"+type": "meta", "+channel": "VAL"}
-
-            field_record.add_info(
-                "Q:group",
-                {pva_table_name: pva_info},
-            )
-
-            field_record_container.record_info = RecordInfo(lambda x: x, None, False)
-
-            field_record_container.record_info.add_record(field_record)
-
 
 def _add_pvi_info(
     pvi: str,
@@ -498,8 +389,6 @@ def datatype_updater(datatype: DataType):
             return builder.WaveformIn(
                 pv, **datatype_to_epics_fields(attribute.datatype), **attribute_fields
             )
-        case Table(numpy_datatype):
-            return create_table(pv, numpy_datatype)
         case _:
             raise FastCSException(
                 f"Unsupported type {type(attribute.datatype)}: {attribute.datatype}"

src/fastcs/datatypes.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-import numpy as np
-from numpy import typing as npt
 from abc import abstractmethod
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass
-from typing import Generic, TypeVar
+from typing import Any, Generic, Literal, TypeVar
+
+import numpy as np
 
-T = TypeVar("T", int, float, bool, str, npt.ArrayLike)
+T = TypeVar("T", int, float, bool, str, np.ndarray)  # type: ignore
 ATTRIBUTE_TYPES: tuple[type] = T.__constraints__  # type: ignore
 
 
@@ -20,7 +20,20 @@ class DataType(Generic[T]):
 
     @property
     @abstractmethod
-    def dtype(self) -> type[T]:  # Using property due to lack of Generic ClassVars
+    def dtype(
+        self,
+    ) -> type[T]:  # Using property due to lack of Generic ClassVars
+        pass
+
+    @property
+    @abstractmethod
+    def initial_value(self) -> T:
+        """Return an initial value for the datatype."""
+        pass
+
+    @abstractmethod
+    def cast(self, value: Any) -> T:
+        """Cast a value to the datatype to put to the backend."""
         pass
 
 
@@ -38,6 +51,17 @@ class Int(DataType[int]):
     def dtype(self) -> type[int]:
         return int
 
+    @property
+    def initial_value(self) -> Literal[0]:
+        return 0
+
+    def cast(self, value: Any) -> int:
+        if self.min is not None and value < self.min:
+            raise ValueError(f"Value {value} is less than minimum {self.min}")
+        if self.max is not None and value > self.max:
+            raise ValueError(f"Value {value} is greater than maximum {self.max}")
+        return int(value)
+
 
 @dataclass(frozen=True)
 class Float(DataType[float]):
@@ -54,6 +78,17 @@ class Float(DataType[float]):
     def dtype(self) -> type[float]:
         return float
 
+    @property
+    def intial_value(self) -> float:
+        return 0.0
+
+    def cast(self, value: Any) -> float:
+        if self.min is not None and value < self.min:
+            raise ValueError(f"Value {value} is less than minimum {self.min}")
+        if self.max is not None and value > self.max:
+            raise ValueError(f"Value {value} is greater than maximum {self.max}")
+        return float(value)
+
 
 @dataclass(frozen=True)
 class Bool(DataType[bool]):
@@ -66,6 +101,13 @@ class Bool(DataType[bool]):
     def dtype(self) -> type[bool]:
         return bool
 
+    @property
+    def intial_value(self) -> Literal[False]:
+        return False
+
+    def cast(self, value: Any) -> bool:
+        return bool(value)
+
 
 @dataclass(frozen=True)
 class String(DataType[str]):
@@ -75,39 +117,45 @@ class String(DataType[str]):
     def dtype(self) -> type[str]:
         return str
 
+    @property
+    def intial_value(self) -> Literal[""]:
+        return ""
 
-@dataclass(frozen=True)
-class WaveForm(DataType[npt.ArrayLike]):
-    """DataType for a waveform"""
+    def cast(self, value: Any) -> str:
+        return str(value)
 
-    length: int | None = None
 
-    @property
-    def dtype(self) -> type[npt.ArrayLike]:
-        return np.ndarray
+DEFAULT_WAVEFORM_LENGTH = 20000
 
 
 @dataclass(frozen=True)
-class Table(DataType[npt.ArrayLike]):
-    """`DataType` mapping to a dictionary of numpy arrays.
-
-    Values should be a dictionary of column name to an `ArrayLike` of columns.
+class WaveForm(DataType[np.ndarray]):
+    """
+    DataType for a waveform, values are of the numpy `datatype`
     """
 
-    numpy_datatype: npt.DTypeLike
+    numpy_datatype: np.dtype
+    length: int = DEFAULT_WAVEFORM_LENGTH
 
     @property
-    def dtype(self) -> type[npt.ArrayLike]:
+    def dtype(self) -> type[np.ndarray]:
         return np.ndarray
 
-
-def validate_value(datatype: DataType[T], value: T) -> T:
-    """Validate a value against a datatype."""
-
-    if isinstance(datatype, (Int | Float)):
-        assert isinstance(value, (int | float)), f"Value {value} is not a number"
-        if datatype.min is not None and value < datatype.min:
-            raise ValueError(f"Value {value} is less than minimum {datatype.min}")
-        if datatype.max is not None and value > datatype.max:
-            raise ValueError(f"Value {value} is greater than maximum {datatype.max}")
-    return value
+    @property
+    def initial_value(self) -> np.ndarray:
+        return np.ndarray(self.length, dtype=self.numpy_datatype)
+
+    def cast(self, value: Sequence | np.ndarray) -> np.ndarray:
+        if len(value) > self.length:
+            raise ValueError(
+                f"Waveform length {len(value)} is greater than maximum {self.length}."
+            )
+        if isinstance(value, np.ndarray):
+            if value.dtype != self.numpy_datatype:
+                raise ValueError(
+                    f"Waveform dtype {value.dtype} does not "
+                    f"match {self.numpy_datatype}."
+                )
+            return value
+        else:
+            return np.array(value, dtype=self.numpy_datatype)