Add API for creating a Bound{Put,Scan,Command} directly

Author: GDYendell

src/fastcs/controller.py

@@ -35,25 +35,14 @@ class method and a controller instance, so that it can be called from any
 
         """
         # Lazy import to avoid circular references
-        from fastcs.cs_methods import (
-            BoundCommand,
-            BoundPut,
-            BoundScan,
-            Command,
-            Put,
-            Scan,
-        )
+        from fastcs.cs_methods import Command, Put, Scan
 
         for attr_name in dir(self):
             attr = getattr(self, attr_name)
             if isinstance(attr, Attribute):
                 setattr(self, attr_name, copy(attr))
-            elif isinstance(attr, Command):
-                setattr(self, attr_name, BoundCommand(attr, self))
-            elif isinstance(attr, Put):
-                setattr(self, attr_name, BoundPut(attr, self))
-            elif isinstance(attr, Scan):
-                setattr(self, attr_name, BoundScan(attr, self))
+            elif isinstance(attr, Put | Scan | Command):
+                setattr(self, attr_name, attr.bind(self))
 
     def register_sub_controller(self, name: str, sub_controller: SubController):
         if name in self.__sub_controller_tree.keys():

src/fastcs/cs_methods.py

@@ -1,6 +1,7 @@
 from asyncio import iscoroutinefunction
 from collections.abc import Callable, Coroutine
 from inspect import Signature, getdoc, signature
+from types import MethodType
 from typing import Any, Generic, TypeVar
 
 from fastcs.controller import BaseController
@@ -13,6 +14,14 @@
 CommandCallback = Callable[[ControllerType], Coroutine[None, None, None]]
 ScanCallback = Callable[[ControllerType], Coroutine[None, None, None]]
 PutCallback = Callable[[ControllerType, Any], Coroutine[None, None, None]]
+BoundCommandCallback = Callable[[], Coroutine[None, None, None]]
+BoundScanCallback = Callable[[], Coroutine[None, None, None]]
+BoundPutCallback = Callable[[Any], Coroutine[None, None, None]]
+
+
+method_not_bound_error = NotImplementedError(
+    "Method must be bound to a controller instance to be callable"
+)
 
 
 class Method(Generic[ControllerType]):
@@ -62,15 +71,21 @@ def __init__(self, fn: ScanCallback[ControllerType], period: float) -> None:
 
         self._period = period
 
+    @property
+    def period(self):
+        return self._period
+
     def _validate(self, fn: ScanCallback[ControllerType]) -> None:
         super()._validate(fn)
 
         if not len(self.parameters) == 1:
             raise FastCSException("Scan method cannot have arguments")
 
-    @property
-    def period(self):
-        return self._period
+    def bind(self, controller: ControllerType) -> "BoundScan":
+        return BoundScan(MethodType(self.fn, controller), self._period)
+
+    def __call__(self):
+        raise method_not_bound_error
 
 
 class Put(Method[ControllerType]):
@@ -83,6 +98,12 @@ def _validate(self, fn: PutCallback[ControllerType]) -> None:
         if not len(self.parameters) == 2:
             raise FastCSException("Put method can only take one argument")
 
+    def bind(self, controller: ControllerType) -> "BoundPut":
+        return BoundPut(MethodType(self.fn, controller))
+
+    def __call__(self, value: Any):
+        raise method_not_bound_error
+
 
 class Command(Method[ControllerType]):
     def __init__(
@@ -96,32 +117,56 @@ def _validate(self, fn: CommandCallback[ControllerType]) -> None:
         if not len(self.parameters) == 1:
             raise FastCSException("Command method cannot have arguments")
 
+    def bind(self, controller: ControllerType) -> "BoundCommand":
+        return BoundCommand(MethodType(self.fn, controller))
 
-class BoundScan(Scan):
-    def __init__(self, scan: Scan[BaseController], controller: BaseController) -> None:
-        super().__init__(scan.fn, scan.period)
+    def __call__(self):
+        raise method_not_bound_error
 
-        self._controller = controller
 
-    async def __call__(self):
-        return await self._fn(self._controller)
+class BoundScan(Method[BaseController]):
+    def __init__(self, fn: BoundScanCallback, period: float):
+        super().__init__(fn)
 
+        self._period = period
 
-class BoundPut(Put):
-    def __init__(self, put: Put, controller: BaseController) -> None:
-        super().__init__(put.fn)
+    @property
+    def period(self):
+        return self._period
 
-        self._controller = controller
+    def _validate(self, fn: BoundScanCallback) -> None:
+        super()._validate(fn)
+
+        if not len(self.parameters) == 0:
+            raise FastCSException("Scan method cannot have arguments")
+
+    def __call__(self):
+        return self._fn()
+
+
+class BoundPut(Method[BaseController]):
+    def __init__(self, fn: BoundPutCallback):
+        super().__init__(fn)
+
+    def _validate(self, fn: BoundPutCallback) -> None:
+        super()._validate(fn)
+
+        if not len(self.parameters) == 1:
+            raise FastCSException("Put method can only take one argument")
 
-    async def __call__(self, value: bool | int | float | str):
-        return await self._fn(self._controller, value)
+    def __call__(self, value: Any):
+        return self._fn(value)
 
 
-class BoundCommand(Command):
-    def __init__(self, command: Command, controller: BaseController) -> None:
-        super().__init__(command.fn)
+class BoundCommand(Method[BaseController]):
+    def __init__(self, fn: BoundCommandCallback):
+        super().__init__(fn)
+
+    def _validate(self, fn: BoundCommandCallback) -> None:
+        super()._validate(fn)
 
-        self._controller = controller
+        if not len(self.parameters) == 0:
+            raise FastCSException("Command method cannot have arguments")
 
-    async def __call__(self):
-        return await self._fn(self._controller)
+    def __call__(self):
+        return self._fn()

src/fastcs/mapping.py

@@ -47,14 +47,20 @@ def get_single_mapping(controller: BaseController) -> SingleMapping:
     for attr_name in dir(controller):
         attr = getattr(controller, attr_name)
         match attr:
+            case Attribute(enabled=True):
+                attributes[attr_name] = attr
+            case BoundPut(enabled=True):
+                put_methods[attr_name] = attr
             case Put(enabled=True):
-                put_methods[attr_name] = BoundPut(attr, controller)
+                put_methods[attr_name] = attr.bind(controller)
+            case BoundScan(enabled=True):
+                scan_methods[attr_name] = attr
             case Scan(enabled=True):
-                scan_methods[attr_name] = BoundScan(attr, controller)
+                scan_methods[attr_name] = attr.bind(controller)
+            case BoundCommand(enabled=True):
+                command_methods[attr_name] = attr
             case Command(enabled=True):
-                command_methods[attr_name] = BoundCommand(attr, controller)
-            case Attribute(enabled=True):
-                attributes[attr_name] = attr
+                command_methods[attr_name] = attr.bind(controller)
             case _:
                 pass
 

tests/test_controller.py

@@ -2,6 +2,7 @@
 
 from fastcs.backend import Backend
 from fastcs.controller import Controller, SubController
+from fastcs.cs_methods import BoundCommand
 from fastcs.mapping import _walk_mappings, get_single_mapping
 from fastcs.wrappers import command
 
@@ -36,11 +37,20 @@ def test_controller_nesting():
 @pytest.mark.asyncio
 async def test_controller_methods():
     class TestController(Controller):
+        def __init__(self):
+            super().__init__()
+            self.do_nothing2 = BoundCommand(self.do_nothing2)
+
         @command()
         async def do_nothing(self):
             pass
 
+        async def do_nothing2(self):
+            pass
+
     c = TestController()
-    b = Backend(c)
     await c.do_nothing()
+    await c.do_nothing2()
+    b = Backend(c)
     await b._mapping.get_controller_mappings()[0].command_methods["do_nothing"]()
+    await b._mapping.get_controller_mappings()[0].command_methods["do_nothing2"]()