Add units, min/max, and alarm limits to Int and Float

Author: evvaaaa

src/fastcs/attributes.py

@@ -3,7 +3,7 @@
 from enum import Enum
 from typing import Any, Generic, Protocol, runtime_checkable
 
-from .datatypes import ATTRIBUTE_TYPES, AttrCallback, DataType, T
+from .datatypes import ATTRIBUTE_TYPES, AttrCallback, DataType, T, validate_value
 
 
 class AttrMode(Enum):
@@ -115,7 +115,7 @@ def get(self) -> T:
         return self._value
 
     async def set(self, value: T) -> None:
-        self._value = self._datatype.dtype(value)
+        self._value = self._datatype.dtype(validate_value(self._datatype, value))
 
         if self._update_callback is not None:
             await self._update_callback(self._value)
@@ -202,6 +202,6 @@ def __init__(
         )
 
     async def process(self, value: T) -> None:
-        await self.set(value)
+        await self.set(validate_value(self._datatype, value))
 
         await super().process(value)  # type: ignore

src/fastcs/datatypes.py

@@ -21,8 +21,20 @@ def dtype(self) -> type[T]:  # Using property due to lack of Generic ClassVars
         pass
 
 
+T_Numerical = TypeVar("T_Numerical", int, float)
+
+
+@dataclass(frozen=True)
+class _Numerical(DataType[T_Numerical]):
+    units: str | None = None
+    min: int | None = None
+    max: int | None = None
+    min_alarm: int | None = None
+    max_alarm: int | None = None
+
+
 @dataclass(frozen=True)
-class Int(DataType[int]):
+class Int(_Numerical[int]):
     """`DataType` mapping to builtin ``int``."""
 
     @property
@@ -31,7 +43,7 @@ def dtype(self) -> type[int]:
 
 
 @dataclass(frozen=True)
-class Float(DataType[float]):
+class Float(_Numerical[float]):
     """`DataType` mapping to builtin ``float``."""
 
     prec: int = 2
@@ -60,3 +72,15 @@ class String(DataType[str]):
     @property
     def dtype(self) -> type[str]:
         return str
+
+
+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