Merge pull request #18 from python-accelerator-middle-layer/17-add-a-real-test-suite-for-pyaml-cs-oa

Test suite and ruff

Author: JeanLucPons

.github/workflows/tests.yml

@@ -0,0 +1,37 @@
+name: run tests
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: "**/pyproject.toml"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install "git+https://github.com/python-accelerator-middle-layer/pyaml.git"
+          python -m pip install -e ".[test,epics,tango]"
+          python -m pip install ruff
+
+      - name: Lint with Ruff
+        run: ruff check --diff .
+
+      - name: Test with pytest
+        run: python -m pytest -q

.gitignore

@@ -1,2 +1,4 @@
 __pycache__/
 *.egg-info/
+.idea
+build

pyaml_cs_oa/__init__.py

@@ -1,14 +1,15 @@
 import asyncio
-import contextlib
-from typing import Awaitable, Any
 import atexit
+import contextlib
+from typing import Any, Awaitable
 
 __version__ = "0.1.2"
 
 # One persistent event loop
 _loop = None
 _nest_asyncio_applied = False
 
+
 def loop() -> asyncio.AbstractEventLoop:
 
     global _loop, _nest_asyncio_applied
@@ -20,6 +21,7 @@ def loop() -> asyncio.AbstractEventLoop:
         if not _nest_asyncio_applied:
             try:
                 import nest_asyncio
+
                 nest_asyncio.apply(running_loop)
                 _nest_asyncio_applied = True
             except ImportError:
@@ -37,14 +39,18 @@ def loop() -> asyncio.AbstractEventLoop:
         if not _nest_asyncio_applied:
             try:
                 import nest_asyncio
+
                 nest_asyncio.apply(_loop)
                 _nest_asyncio_applied = True
             except ImportError:
                 pass
 
     return _loop
+
+
 loop()  # Make sure to initialize `_loop`
 
+
 def _reap_done_tasks(evloop: asyncio.AbstractEventLoop) -> None:
     """Reap exceptions from tasks that are already DONE on this loop.
     Does not cancel or otherwise touch pending tasks.
@@ -76,4 +82,3 @@ def arun(coro: Awaitable[Any]) -> Any:
         # Clean up completed/cancelled tasks so residual CancelledError
         # doesn't leak to next run
         _reap_done_tasks(evloop)
-

pyaml_cs_oa/container.py

@@ -2,7 +2,6 @@
 import inspect
 from collections.abc import Awaitable, Callable
 from typing import TypeVar
-from .signal import OASignal
 
 from ophyd_async.core import (
     SignalDatatypeT,
@@ -11,9 +10,11 @@
     set_and_wait_for_other_value,
 )
 
+from . import arun
+from .signal import OASignal
+
 T = TypeVar("T")
 
-from . import arun
 
 def _looks_disconnected(exc: BaseException) -> bool:
     # Keep it generic: ophyd-async wraps cancellations in TimeoutError;
@@ -46,7 +47,7 @@ async def _recover_once(
             raise
 
 
-class OAReadback():
+class OAReadback:
     """A readback object."""
 
     def __init__(self, r_signal: SignalR[SignalDatatypeT]):
@@ -80,15 +81,16 @@ def get(self) -> SignalDatatypeT:
         """Synchronous wrapper around `async_get()`."""
         return arun(self.async_get())
 
-class OASetpoint():
+
+class OASetpoint:
     def __init__(
         self,
         w_signal: SignalW[SignalDatatypeT],
         r_signal: SignalR[SignalDatatypeT] | None = None,
     ):
         self._w_sig = w_signal
-        self._r_sig = r_signal # used only for `set_and_wait()`
-        self._has_r_sig = (r_signal is not None)
+        self._r_sig = r_signal  # used only for `set_and_wait()`
+        self._has_r_sig = r_signal is not None
 
     async def _run_get(self) -> SignalDatatypeT:
         await self._w_sig.connect()
@@ -139,9 +141,7 @@ async def _rebuild_both(self) -> None:
 
     async def _run_set_and_wait(self, value) -> None:
         if not self._has_r_sig:
-            raise RuntimeError(
-                "Cannot use set_and_wait() without a matching readback signal."
-            )
+            raise RuntimeError("Cannot use set_and_wait() without a matching readback signal.")
         await self._reconnect_both()
         await set_and_wait_for_other_value(self._w_sig, value, self._r_sig, value)
 
@@ -153,9 +153,9 @@ async def async_set_and_wait(self, value) -> None:
         )
 
     async def _complete_set(self, value):
-            status = await self.async_set(value)
-            await status  # Wait for completion before returning
-            return status
+        status = await self.async_set(value)
+        await status  # Wait for completion before returning
+        return status
 
     def set(self, value):
         """Synchronous wrapper around `async_set()`."""
@@ -167,4 +167,4 @@ def get(self) -> SignalDatatypeT:
 
     def set_and_wait(self, value) -> None:
         """Synchronous wrapper around `async_set_and_wait()`."""
-        return arun(self.async_set_and_wait(value))
+        return arun(self.async_set_and_wait(value))

pyaml_cs_oa/controlsystem.py

@@ -1,33 +1,32 @@
-import os
-import logging
 import copy
+import logging
+import os
 
+from pyaml.common.exception import PyAMLException
 from pyaml.control.controlsystem import ControlSystem
 from pydantic import BaseModel
-from pyaml.common.exception import PyAMLException
-
-PYAMLCLASS : str = "OphydAsyncControlSystem"
-
-logger = logging.getLogger(__name__)
 
+from . import __version__
+from .epicsR import EpicsR
+from .epicsRW import EpicsRW
+from .epicsW import EpicsW
+from .signal import OASignal
+from .tangoR import TangoR
+from .tangoRW import TangoRW
 from .types import (
     EpicsConfigR,
-    EpicsConfigW,
     EpicsConfigRW,
+    EpicsConfigW,
     TangoConfigR,
     TangoConfigRW,
 )
-from .signal import OASignal
-from .epicsR import EpicsR
-from .epicsW import EpicsW
-from .epicsRW import EpicsRW
-from .tangoR import TangoR
-from .tangoRW import TangoRW
 
-from . import __version__
+PYAMLCLASS: str = "OphydAsyncControlSystem"
+
+logger = logging.getLogger(__name__)
 
-class ConfigModel(BaseModel):
 
+class ConfigModel(BaseModel):
     """
     Configuration model for an OA Control System.
 
@@ -36,21 +35,21 @@ class ConfigModel(BaseModel):
     name : str
         Name of the control system.
     prefix : str
-        Prefix added to the PV or attribute name. It can be a 
+        Prefix added to the PV or attribute name. It can be a
         for instance, TANGO_HOST, or a PV prefix.
     debug_level : int
         Debug verbosity level.
     scalar_aggregator : str
-        Aggregator module for scalar values. If none specified, writings and 
-        readings of sclar value are serialized. 
+        Aggregator module for scalar values. If none specified, writings and
+        readings of sclar value are serialized.
     vector_aggregator : str
         Aggregator module for vecrors. If none specified, writings and readings
         of vector are serialized,
     """
 
     name: str
     prefix: str = ""
-    debug_level: str=None
+    debug_level: str = None
     scalar_aggregator: str | None = "pyaml_cs_oa.scalar_aggregator"
     vector_aggregator: str | None = None
 
@@ -61,57 +60,62 @@ class OphydAsyncControlSystem(ControlSystem):
     def __init__(self, cfg: ConfigModel):
         super().__init__()
         self._cfg = cfg
-        self._devices = {} # Dict containing all attached DeviceAccess
+        self._devices = {}  # Dict containing all attached DeviceAccess
 
         if self._cfg.debug_level:
-          log_level = getattr(logging, self._cfg.debug_level, logging.WARNING)
-          logger.parent.setLevel(log_level)
-          logger.setLevel(log_level)
+            log_level = getattr(logging, self._cfg.debug_level, logging.WARNING)
+            logger.parent.setLevel(log_level)
+            logger.setLevel(log_level)
+
+        logger.log(
+            logging.WARNING,
+            f"PyAML OA control system binding ({__version__}) initialized with name '{self._cfg.name}'"
+            f" and prefix='{self._cfg.prefix}'",
+        )
 
-        logger.log(logging.WARNING, f"PyAML OA control system binding ({__version__}) initialized with name '{self._cfg.name}'"
-                                 f" and prefix='{self._cfg.prefix}'")
-        
     def attach(self, devs: list[OASignal]) -> list[OASignal]:
-        return self._attach(devs,False)
+        return self._attach(devs, False)
 
     def attach_array(self, devs: list[OASignal]) -> list[OASignal]:
-        return self._attach(devs,True)
+        return self._attach(devs, True)
 
-    def _attach(self, devs: list[OASignal],is_array:bool) -> list[OASignal]:
+    def _attach(self, devs: list[OASignal], is_array: bool) -> list[OASignal]:
         # Concatenate the prefix
         newDevs = []
-        for d in devs:            
+        for d in devs:
             if d is not None:
-
                 sig_cfg = d._cfg
                 sig_cfg_cls = sig_cfg.__class__
-                
-                if isinstance(d._cfg,EpicsConfigR):
+
+                if isinstance(d._cfg, EpicsConfigR):
                     key = self._cfg.prefix + d._cfg.read_pvname
                     sig_cls = EpicsR
                     config = dict(read_pvname=key)
-                elif isinstance(d._cfg,EpicsConfigW):
+                elif isinstance(d._cfg, EpicsConfigW):
                     key = self._cfg.prefix + d._cfg.write_pvname
                     sig_cls = EpicsW
                     config = dict(write_pvname=key)
-                elif isinstance(d._cfg,EpicsConfigRW):
+                elif isinstance(d._cfg, EpicsConfigRW):
                     key = self._cfg.prefix + d._cfg.read_pvname + d._cfg.write_pvname
                     sig_cls = EpicsRW
-                    config = dict(read_pvname=self._cfg.prefix + d._cfg.read_pvname, write_pvname=self._cfg.prefix + d._cfg.write_pvname)
-                elif isinstance(d._cfg,TangoConfigR):
+                    config = dict(
+                        read_pvname=self._cfg.prefix + d._cfg.read_pvname,
+                        write_pvname=self._cfg.prefix + d._cfg.write_pvname,
+                    )
+                elif isinstance(d._cfg, TangoConfigR):
                     key = self._cfg.prefix + d._cfg.attribute
                     sig_cls = TangoR
                     config = dict(attribute=key)
-                elif isinstance(d._cfg,TangoConfigRW):
+                elif isinstance(d._cfg, TangoConfigRW):
                     key = self._cfg.prefix + d._cfg.attribute
                     sig_cls = TangoRW
                     config = dict(attribute=key)
                 else:
                     raise PyAMLException(f"OphydAsyncControlSystem: Unsupported type {type(sig_cfg)}")
 
                 if key not in self._devices:
-                    n_conf =  dict(d._cfg) | config
-                    nr = sig_cls(sig_cfg_cls(**n_conf),is_array)
+                    n_conf = dict(d._cfg) | config
+                    nr = sig_cls(sig_cfg_cls(**n_conf), is_array)
                     nr.build()
                     self._devices[key] = nr
 
@@ -130,7 +134,7 @@ def name(self) -> str:
             Name of the control system.
         """
         return self._cfg.name
-    
+
     def scalar_aggregator(self) -> str | None:
         """
         Returns the module name used for handling aggregator of DeviceAccess
@@ -145,7 +149,7 @@ def scalar_aggregator(self) -> str | None:
     def vector_aggregator(self) -> str | None:
         """
         Returns the module name used for handling aggregator of DeviceVectorAccess
-        
+
         Returns
         -------
         str
@@ -154,4 +158,4 @@ def vector_aggregator(self) -> str | None:
         return self._cfg.vector_aggregator
 
     def __repr__(self):
-       return repr(self._cfg).replace("ConfigModel",self.__class__.__name__)
+        return repr(self._cfg).replace("ConfigModel", self.__class__.__name__)