Fix some pyright strict errors

Refactor Method classes to be generic over ControllerType

Author: GDYendell

pyproject.toml

@@ -14,7 +14,7 @@ dependencies = [
     "aioserial",
     "numpy",
     "pydantic",
-    "pvi~=0.10.0",
+    "pvi~=0.10.1",
     "pytango",
     "softioc",
 ]

src/fastcs/attributes.py

@@ -18,7 +18,7 @@ class AttrMode(Enum):
 class Sender(Protocol):
     """Protocol for setting the value of an ``Attribute``."""
 
-    async def put(self, controller: Any, attr: AttrW, value: Any) -> None:
+    async def put(self, controller: Any, attr: AttrW[T], value: Any) -> None:
         pass
 
 
@@ -28,7 +28,7 @@ class Updater(Protocol):
 
     update_period: float
 
-    async def update(self, controller: Any, attr: AttrR) -> None:
+    async def update(self, controller: Any, attr: AttrR[T]) -> None:
         pass
 
 
@@ -89,7 +89,7 @@ class AttrR(Attribute[T]):
     def __init__(
         self,
         datatype: DataType[T],
-        access_mode=AttrMode.READ,
+        access_mode: AttrMode = AttrMode.READ,
         group: str | None = None,
         handler: Updater | None = None,
         allowed_values: list[T] | None = None,
@@ -128,7 +128,7 @@ class AttrW(Attribute[T]):
     def __init__(
         self,
         datatype: DataType[T],
-        access_mode=AttrMode.WRITE,
+        access_mode: AttrMode = AttrMode.WRITE,
         group: str | None = None,
         handler: Sender | None = None,
         allowed_values: list[T] | None = None,
@@ -176,7 +176,7 @@ class AttrRW(AttrW[T], AttrR[T]):
     def __init__(
         self,
         datatype: DataType[T],
-        access_mode=AttrMode.READ_WRITE,
+        access_mode: AttrMode = AttrMode.READ_WRITE,
         group: str | None = None,
         handler: Handler | None = None,
         allowed_values: list[T] | None = None,

src/fastcs/backend.py

@@ -1,23 +1,26 @@
 import asyncio
 from collections import defaultdict
-from collections.abc import Callable
+from collections.abc import Callable, Coroutine
 from concurrent.futures import Future
-from types import MethodType
 
 from softioc.asyncio_dispatcher import AsyncioDispatcher
 
+from fastcs.datatypes import T
+
 from .attributes import AttrR, AttrW, Sender, Updater
-from .controller import Controller
+from .controller import BaseController, Controller
 from .exceptions import FastCSException
 from .mapping import Mapping, SingleMapping
 
+Callback = Callable[[], Coroutine[None, None, None]]
+
 
 class Backend:
     def __init__(
         self, controller: Controller, loop: asyncio.AbstractEventLoop | None = None
     ):
         self._dispatcher = AsyncioDispatcher(loop)
-        self._loop = self._dispatcher.loop
+        self._loop: asyncio.AbstractEventLoop = self._dispatcher.loop  # type: ignore
         self._controller = controller
 
         self._initial_tasks = [controller.connect]
@@ -58,20 +61,20 @@ def _start_scan_tasks(self):
         for task in scan_tasks:
             asyncio.run_coroutine_threadsafe(task(), self._loop)
 
-    def _run(self):
+    def _run(self) -> None:
         raise NotImplementedError("Specific Backend must implement _run")
 
 
-def _link_single_controller_put_tasks(single_mapping: SingleMapping) -> None:
-    for name, method in single_mapping.put_methods.items():
+def _link_single_controller_put_tasks(
+    single_mapping: SingleMapping,
+) -> None:
+    for name, put in single_mapping.put_methods.items():
         name = name.removeprefix("put_")
 
         attribute = single_mapping.attributes[name]
         match attribute:
             case AttrW():
-                attribute.set_process_callback(
-                    MethodType(method.fn, single_mapping.controller)
-                )
+                attribute.set_process_callback(put)
             case _:
                 raise FastCSException(
                     f"Mode {attribute.access_mode} does not "
@@ -89,17 +92,28 @@ def _link_attribute_sender_class(single_mapping: SingleMapping) -> None:
 
                 callback = _create_sender_callback(attribute, single_mapping.controller)
                 attribute.set_process_callback(callback)
+            case _:
+                pass
 
 
-def _create_sender_callback(attribute, controller):
-    async def callback(value):
-        await attribute.sender.put(controller, attribute, value)
+def _create_sender_callback(
+    attribute: AttrW[T], controller: BaseController
+) -> Callable[[T], Coroutine[None, None, None]]:
+    match attribute.sender:
+        case Sender() as sender:
 
-    return callback
+            async def put_callback(value: T):
+                await sender.put(controller, attribute, value)
+        case _:
+
+            async def put_callback(value: T):
+                pass
 
+    return put_callback
 
-def _get_scan_tasks(mapping: Mapping) -> list[Callable]:
-    scan_dict: dict[float, list[Callable]] = defaultdict(list)
+
+def _get_scan_tasks(mapping: Mapping) -> list[Callback]:
+    scan_dict: dict[float, list[Callback]] = defaultdict(list)
 
     for single_mapping in mapping.get_controller_mappings():
         _add_scan_method_tasks(scan_dict, single_mapping)
@@ -110,16 +124,15 @@ def _get_scan_tasks(mapping: Mapping) -> list[Callable]:
 
 
 def _add_scan_method_tasks(
-    scan_dict: dict[float, list[Callable]], single_mapping: SingleMapping
+    scan_dict: dict[float, list[Callback]], single_mapping: SingleMapping
 ):
-    for method in single_mapping.scan_methods.values():
-        scan_dict[method.period].append(
-            MethodType(method.fn, single_mapping.controller)
-        )
+    for scan in single_mapping.scan_methods.values():
+        scan_dict[scan.period].append(scan)
 
 
 def _add_attribute_updater_tasks(
-    scan_dict: dict[float, list[Callable]], single_mapping: SingleMapping
+    scan_dict: dict[float, list[Callback]],
+    single_mapping: SingleMapping,
 ):
     for attribute in single_mapping.attributes.values():
         match attribute:
@@ -128,12 +141,20 @@ def _add_attribute_updater_tasks(
                     attribute, single_mapping.controller
                 )
                 scan_dict[update_period].append(callback)
+            case _:
+                pass
 
 
-def _create_updater_callback(attribute, controller):
+def _create_updater_callback(
+    attribute: AttrR[T], controller: BaseController
+) -> Callback:
     async def callback():
         try:
-            await attribute.updater.update(controller, attribute)
+            match attribute.updater:
+                case Updater() as updater:
+                    await updater.update(controller, attribute)
+                case _:
+                    pass
         except Exception as e:
             print(
                 f"Update loop in {attribute.updater} stopped:\n"
@@ -144,15 +165,15 @@ async def callback():
     return callback
 
 
-def _get_periodic_scan_tasks(scan_dict: dict[float, list[Callable]]) -> list[Callable]:
-    periodic_scan_tasks: list[Callable] = []
+def _get_periodic_scan_tasks(scan_dict: dict[float, list[Callback]]) -> list[Callback]:
+    periodic_scan_tasks: list[Callback] = []
     for period, methods in scan_dict.items():
         periodic_scan_tasks.append(_create_periodic_scan_task(period, methods))
 
     return periodic_scan_tasks
 
 
-def _create_periodic_scan_task(period, methods: list[Callable]) -> Callable:
+def _create_periodic_scan_task(period: float, methods: list[Callback]) -> Callback:
     async def scan_task() -> None:
         while True:
             await asyncio.gather(*[method() for method in methods])

src/fastcs/backends/epics/gui.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
+from typing import Any
 
 from pvi._format.dls import DLSFormatter
 from pvi.device import (
@@ -28,9 +29,9 @@
 
 from fastcs.attributes import Attribute, AttrR, AttrRW, AttrW
 from fastcs.cs_methods import Command
-from fastcs.datatypes import Bool, Float, Int, String
+from fastcs.datatypes import Bool, Float, Int, String, T
 from fastcs.exceptions import FastCSException
-from fastcs.mapping import Mapping, SingleMapping, _get_single_mapping
+from fastcs.mapping import Mapping, SingleMapping, get_single_mapping
 from fastcs.util import snake_to_pascal
 
 
@@ -56,7 +57,7 @@ def _get_pv(self, attr_path: list[str], name: str):
         return f"{attr_prefix}:{name.title().replace('_', '')}"
 
     @staticmethod
-    def _get_read_widget(attribute: AttrR) -> ReadWidgetUnion:
+    def _get_read_widget(attribute: AttrR[T]) -> ReadWidgetUnion:
         match attribute.datatype:
             case Bool():
                 return LED()
@@ -68,10 +69,11 @@ def _get_read_widget(attribute: AttrR) -> ReadWidgetUnion:
                 raise FastCSException(f"Unsupported type {type(datatype)}: {datatype}")
 
     @staticmethod
-    def _get_write_widget(attribute: AttrW) -> WriteWidgetUnion:
+    def _get_write_widget(attribute: AttrW[T]) -> WriteWidgetUnion:
         match attribute.allowed_values:
             case allowed_values if allowed_values is not None:
-                return ComboBox(choices=allowed_values)
+                choices = [v for v in allowed_values if isinstance(v, str)]
+                return ComboBox(choices=choices)
             case _:
                 pass
 
@@ -86,7 +88,7 @@ def _get_write_widget(attribute: AttrW) -> WriteWidgetUnion:
                 raise FastCSException(f"Unsupported type {type(datatype)}: {datatype}")
 
     def _get_attribute_component(
-        self, attr_path: list[str], name: str, attribute: Attribute
+        self, attr_path: list[str], name: str, attribute: Attribute[Any]
     ) -> SignalR | SignalW | SignalRW:
         pv = self._get_pv(attr_path, name)
         name = name.title().replace("_", "")
@@ -148,7 +150,7 @@ def extract_mapping_components(self, mapping: SingleMapping) -> Tree:
                     name=snake_to_pascal(name),
                     layout=SubScreen(),
                     children=self.extract_mapping_components(
-                        _get_single_mapping(sub_controller)
+                        get_single_mapping(sub_controller)
                     ),
                 )
             )

src/fastcs/backends/epics/ioc.py

@@ -1,6 +1,5 @@
-from collections.abc import Callable
+from collections.abc import Callable, Coroutine
 from dataclasses import dataclass
-from types import MethodType
 from typing import Any, Literal
 
 from softioc import builder, softioc
@@ -156,6 +155,7 @@ def _create_and_link_attribute_pvs(pv_prefix: str, mapping: Mapping) -> None:
 def _create_and_link_read_pv(
     pv_prefix: str, pv_name: str, attr_name: str, attribute: AttrR[T]
 ) -> None:
+    record = _get_input_record(f"{pv_prefix}:{pv_name}", attribute)
     if attr_is_enum(attribute):
 
         async def async_record_set(value: T):
@@ -165,13 +165,12 @@ async def async_record_set(value: T):
         async def async_record_set(value: T):
             record.set(value)
 
-    record = _get_input_record(f"{pv_prefix}:{pv_name}", attribute)
     _add_attr_pvi_info(record, pv_prefix, attr_name, "r")
 
     attribute.set_update_callback(async_record_set)
 
 
-def _get_input_record(pv: str, attribute: AttrR) -> RecordWrapper:
+def _get_input_record(pv: str, attribute: AttrR[T]) -> RecordWrapper:
     if attr_is_enum(attribute):
         assert attribute.allowed_values is not None and all(
             isinstance(v, str) for v in attribute.allowed_values
@@ -199,31 +198,40 @@ def _create_and_link_write_pv(
 ) -> None:
     if attr_is_enum(attribute):
 
-        async def on_update(value):
+        async def on_update_enum(value: int):
             await attribute.process_without_display_update(
                 enum_index_to_value(attribute, value)
             )
 
+        record = _get_output_record(
+            f"{pv_prefix}:{pv_name}", attribute, on_update=on_update_enum
+        )
+
         async def async_write_display(value: T):
             record.set(enum_value_to_index(attribute, value), process=False)
 
     else:
 
-        async def on_update(value):
+        async def on_update(value: T):
             await attribute.process_without_display_update(value)
 
+        record = _get_output_record(
+            f"{pv_prefix}:{pv_name}", attribute, on_update=on_update
+        )
+
         async def async_write_display(value: T):
             record.set(value, process=False)
 
-    record = _get_output_record(
-        f"{pv_prefix}:{pv_name}", attribute, on_update=on_update
-    )
     _add_attr_pvi_info(record, pv_prefix, attr_name, "w")
 
     attribute.set_write_display_callback(async_write_display)
 
 
-def _get_output_record(pv: str, attribute: AttrW, on_update: Callable) -> Any:
+def _get_output_record(
+    pv: str,
+    attribute: AttrW[T],
+    on_update: Callable[..., Coroutine[None, None, None]],
+) -> Any:
     if attr_is_enum(attribute):
         assert attribute.allowed_values is not None and all(
             isinstance(v, str) for v in attribute.allowed_values
@@ -255,26 +263,24 @@ def _get_output_record(pv: str, attribute: AttrW, on_update: Callable) -> Any:
 def _create_and_link_command_pvs(pv_prefix: str, mapping: Mapping) -> None:
     for single_mapping in mapping.get_controller_mappings():
         path = single_mapping.controller.path
-        for attr_name, method in single_mapping.command_methods.items():
+        for attr_name, command in single_mapping.command_methods.items():
             pv_name = attr_name.title().replace("_", "")
             _pv_prefix = ":".join([pv_prefix] + path)
             if len(f"{_pv_prefix}:{pv_name}") > EPICS_MAX_NAME_LENGTH:
                 print(
                     f"Not creating PV for {attr_name} as full name would exceed"
                     f" {EPICS_MAX_NAME_LENGTH} characters"
                 )
-                method.enabled = False
+                command.enabled = False
             else:
-                _create_and_link_command_pv(
-                    _pv_prefix,
-                    pv_name,
-                    attr_name,
-                    MethodType(method.fn, single_mapping.controller),
-                )
+                _create_and_link_command_pv(_pv_prefix, pv_name, attr_name, command)
 
 
 def _create_and_link_command_pv(
-    pv_prefix: str, pv_name: str, attr_name: str, method: Callable
+    pv_prefix: str,
+    pv_name: str,
+    attr_name: str,
+    method: Callable[[], Coroutine[None, None, None]],
 ) -> None:
     async def wrapped_method(_: Any):
         await method()

src/fastcs/backends/epics/util.py

@@ -25,7 +25,7 @@
 MBB_MAX_CHOICES = len(_MBB_FIELD_PREFIXES)
 
 
-def attr_is_enum(attribute: Attribute) -> bool:
+def attr_is_enum(attribute: Attribute[T]) -> bool:
     """Check if the `Attribute` has a `String` datatype and has `allowed_values` set.
 
     Args: