Allow binding Attribute to Controller via __setattr__

Author: GDYendell

src/fastcs/attributes.py

@@ -47,6 +47,9 @@ def __init__(
         # changing the units on an int. This should be implemented in the backend.
         self._update_datatype_callbacks: list[Callable[[DataType[T]], None]] = []
 
+        # Name to be filled in by Controller when the Attribute is bound
+        self._name = None
+
     @property
     def io_ref(self) -> AttributeIORefT:
         if self._io_ref is None:
@@ -82,8 +85,16 @@ def update_datatype(self, datatype: DataType[T]) -> None:
         for callback in self._update_datatype_callbacks:
             callback(datatype)
 
+    def set_name(self, name: list[str]):
+        if self._name:
+            raise ValueError(
+                f"Attribute is already registered with a controller as {self._name}"
+            )
+
+        self._name = name
+
     def __repr__(self):
-        return f"{self.__class__.__name__}({self._datatype})"
+        return f"{self.__class__.__name__}({self._name}, {self._datatype})"
 
 
 class AttrR(Attribute[T, AttributeIORefT]):

src/fastcs/controller.py

@@ -131,18 +131,7 @@ class method and a controller instance, so that it can be called from any
 
             attr = getattr(self, attr_name, None)
             if isinstance(attr, Attribute):
-                if (
-                    attr_name in self.attributes
-                    and self.attributes[attr_name] is not attr
-                ):
-                    raise ValueError(
-                        f"`{type(self).__name__}` has conflicting attribute "
-                        f"`{attr_name}` already present in the attributes dict."
-                    )
-
-                new_attribute = deepcopy(attr)
-                setattr(self, attr_name, new_attribute)
-                self.attributes[attr_name] = new_attribute
+                setattr(self, attr_name, deepcopy(attr))
             elif isinstance(attr, UnboundPut | UnboundScan | UnboundCommand):
                 setattr(self, attr_name, attr.bind(self))
 
@@ -164,6 +153,22 @@ def _validate_io(self, ios: Sequence[AttributeIO[T, AttributeIORefT]]):
                 f"{attr.io_ref.__class__.__name__}"
             )
 
+    def add_attribute(self, name, attribute: Attribute):
+        if name in self.attributes and attribute is not self.attributes[name]:
+            raise ValueError(
+                f"Cannot add attribute {name}. "
+                f"Controller {self} has has existing attribute {name}"
+            )
+        elif name in self.__sub_controller_tree.keys():
+            raise ValueError(
+                f"Cannot add attribute {name}. "
+                f"Controller {self} has existing sub controller {name}"
+            )
+
+        attribute.set_name(name)
+        self.attributes[name] = attribute
+        super().__setattr__(name, attribute)
+
     def register_sub_controller(self, name: str, sub_controller: Controller):
         if name in self.__sub_controller_tree.keys():
             raise ValueError(
@@ -190,6 +195,12 @@ def __repr__(self):
 {type(self).__name__}({self.path}, {list(self.__sub_controller_tree.keys())})\
 """
 
+    def __setattr__(self, name, value):
+        if isinstance(value, Attribute):
+            self.add_attribute(name, value)
+        else:
+            super().__setattr__(name, value)
+
 
 class Controller(BaseController):
     """Top-level controller for a device.

tests/test_controller.py

@@ -39,21 +39,18 @@ def __init__(self):
 
 
 class SomeController(Controller):
-    annotated_attr: AttrR
     annotated_attr_not_defined_in_init: AttrR[int]
     equal_attr = AttrR(Int())
     annotated_and_equal_attr: AttrR[int] = AttrR(Int())
 
     def __init__(self, sub_controller: Controller):
-        self.attributes = {}
+        super().__init__()
 
-        self.annotated_attr = AttrR(Int())
         self.attr_on_object = AttrR(Int())
 
         self.attributes["_attributes_attr"] = AttrR(Int())
         self.attributes["_attributes_attr_equal"] = self.equal_attr
 
-        super().__init__()
         self.register_sub_controller("sub_controller", sub_controller)
 
 
@@ -63,7 +60,7 @@ def test_attribute_parsing():
 
     assert set(controller.attributes.keys()) == {
         "_attributes_attr",
-        "annotated_attr",
+        "attr_on_object",
         "_attributes_attr_equal",
         "annotated_and_equal_attr",
         "equal_attr",
@@ -81,21 +78,15 @@ def test_attribute_parsing():
     }
 
 
-def test_attribute_in_both_class_and_get_attributes():
+def test_attribute_in_both_class_and_get_attributes_fails():
     class FailingController(Controller):
         duplicate_attribute = AttrR(Int())
 
         def __init__(self):
-            self.attributes = {"duplicate_attribute": AttrR(Int())}
             super().__init__()
+            self.duplicate_attribute = AttrR(Int())
 
-    with pytest.raises(
-        ValueError,
-        match=(
-            "`FailingController` has conflicting attribute `duplicate_attribute` "
-            "already present in the attributes dict."
-        ),
-    ):
+    with pytest.raises(ValueError, match="existing attribute"):
         FailingController()