Add validate to DataType to check value against min/max

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):
@@ -126,15 +126,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.validate(value)
 
         if self._update_callback is not None:
             await self._update_callback(self._value)
@@ -177,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
@@ -221,6 +223,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/datatypes.py

@@ -5,6 +5,7 @@
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 
+T_Numerical = TypeVar("T_Numerical", int, float)
 T = TypeVar("T", int, float, bool, str)
 ATTRIBUTE_TYPES: tuple[type] = T.__constraints__  # type: ignore
 
@@ -21,8 +22,13 @@ class DataType(Generic[T]):
     def dtype(self) -> type[T]:  # Using property due to lack of Generic ClassVars
         pass
 
+    def validate(self, value: T) -> T:
+        """Validate a value against fields in the datatype."""
+        return value
 
-T_Numerical = TypeVar("T_Numerical", int, float)
+    @property
+    def initial_value(self) -> T:
+        return self.dtype()
 
 
 @dataclass(frozen=True)
@@ -33,6 +39,13 @@ class _Numerical(DataType[T_Numerical]):
     min_alarm: int | None = None
     max_alarm: int | None = None
 
+    def validate(self, value: T_Numerical) -> T_Numerical:
+        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 value
+
 
 @dataclass(frozen=True)
 class Int(_Numerical[int]):
@@ -73,15 +86,3 @@ 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