pyaml-cs-oa 0.1.0__tar.gz

pyaml_cs_oa-0.1.0/.github/workflows/deploy-pypi.yaml

@@ -0,0 +1,35 @@
+name: Publish Python Package
+
+on:
+  push:
+    tags:
+      - '[0-9]+.[0-9]+.[0-9]+'
+  workflow_dispatch:
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    #environment: release
+    permissions:
+      id-token: write
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        cache: pip
+        cache-dependency-path: '**/pyproject.toml'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install hatch
+    - name: Build package
+      run: hatch build
+    #- name: Test package
+    #  run: hatch run test
+    - name: Publish
+      uses: pypa/gh-action-pypi-publish@release/v1

pyaml_cs_oa-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.egg-info/

pyaml_cs_oa-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,21 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.14.5
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.18.2
+    hooks:
+      - id: mypy
+        additional_dependencies: [
+          "pydantic>=2.0",
+        ]

pyaml_cs_oa-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: pyaml-cs-oa
+Version: 0.1.0
+Summary: PyAML control system plugin for ophyd-async
+Maintainer-email: Yoshiteru Hidaka <yhidaka@bnl.gov>
+Keywords: Accelerator,Commissioning,Digital Twin,EPICS,Operation,Synchrotron,Tango,Tuning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Requires-Dist: ophyd-async
+Requires-Dist: pyaml
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: ophyd-async[ca,pva]; extra == 'dev'
+Requires-Dist: ophyd-async[tango]; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: epics
+Requires-Dist: ophyd-async[ca,pva]; extra == 'epics'
+Provides-Extra: tango
+Requires-Dist: ophyd-async[tango]; extra == 'tango'
+Description-Content-Type: text/markdown
+
+# `pyaml-cs-oa`
+
+**PyAML control system plugin for ophyd-async**
+
+`pyaml-cs-oa` is a plugin for `PyAML` based on `ophyd-async`, which
+currently supports EPICS and Tango control systems.
+
+---
+
+## 🔧 Installation
+
+### **Requirements**
+
+- Python **3.11+**
+
+- Depending on your runtime environment, you may want to install support for EPICS or Tango.
+
+### **EPICS CA/PVA Support**
+
+```
+pip install pyaml-cs-oa[epics]
+```
+
+This installs:
+
+- `ophyd-async[ca,pva]`
+
+### **Tango Support**
+
+```
+pip install pyaml-cs-oa[tango]
+```
+
+This installs:
+
+- `ophyd-async[tango]`
+
+---
+
+## 🧪 Developer Installation
+
+If you are contributing, debugging, or running the test suite (no test
+currently provided):
+
+```
+pip install pyaml-cs-oa[dev]
+```
+
+This installs:
+
+- `ophyd-async[ca,pva]`
+- `ophyd-async[tango]`
+- `pre-commit`
+- `ruff`
+- `mypy`
+- `pytest`
+
+### Setup pre-commit hooks
+
+```
+pre-commit install
+```

pyaml_cs_oa-0.1.0/README.md

@@ -0,0 +1,62 @@
+# `pyaml-cs-oa`
+
+**PyAML control system plugin for ophyd-async**
+
+`pyaml-cs-oa` is a plugin for `PyAML` based on `ophyd-async`, which
+currently supports EPICS and Tango control systems.
+
+---
+
+## 🔧 Installation
+
+### **Requirements**
+
+- Python **3.11+**
+
+- Depending on your runtime environment, you may want to install support for EPICS or Tango.
+
+### **EPICS CA/PVA Support**
+
+```
+pip install pyaml-cs-oa[epics]
+```
+
+This installs:
+
+- `ophyd-async[ca,pva]`
+
+### **Tango Support**
+
+```
+pip install pyaml-cs-oa[tango]
+```
+
+This installs:
+
+- `ophyd-async[tango]`
+
+---
+
+## 🧪 Developer Installation
+
+If you are contributing, debugging, or running the test suite (no test
+currently provided):
+
+```
+pip install pyaml-cs-oa[dev]
+```
+
+This installs:
+
+- `ophyd-async[ca,pva]`
+- `ophyd-async[tango]`
+- `pre-commit`
+- `ruff`
+- `mypy`
+- `pytest`
+
+### Setup pre-commit hooks
+
+```
+pre-commit install
+```

pyaml_cs_oa-0.1.0/pyaml_cs_oa/__init__.py

@@ -0,0 +1,79 @@
+import asyncio
+import contextlib
+from typing import Awaitable, Any
+import atexit
+
+__version__ = "0.1.0"
+
+# One persistent event loop
+_loop = None
+_nest_asyncio_applied = False
+
+def loop() -> asyncio.AbstractEventLoop:
+
+    global _loop, _nest_asyncio_applied
+
+    # Try to get the currently running loop (e.g., in Jupyter)
+    try:
+        running_loop = asyncio.get_running_loop()
+        # We found a running loop (Jupyter case)
+        if not _nest_asyncio_applied:
+            try:
+                import nest_asyncio
+                nest_asyncio.apply(running_loop)
+                _nest_asyncio_applied = True
+            except ImportError:
+                pass
+        return running_loop
+    except RuntimeError:
+        # No running loop, create our own
+        pass
+
+    if _loop is None or _loop.is_closed():
+        _loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(_loop)
+
+        # Apply nest_asyncio to our new loop
+        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.
+    """
+    if evloop is None or evloop.is_closed():
+        return
+
+    try:
+        # Snapshot; tasks may change during iteration
+        for t in tuple(asyncio.all_tasks(evloop)):
+            if not t.done():
+                continue
+            # If the task is cancelled, .result() raises CancelledError — suppress that.
+            # If the task failed, .result() raises its exception — suppress to just mark it retrieved.
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                t.result()
+    except (RuntimeError, AttributeError):
+        # During shutdown, asyncio may be partially cleaned up
+        pass
+
+
+def arun(coro: Awaitable[Any]) -> Any:
+
+    evloop = loop()
+
+    try:
+        return evloop.run_until_complete(coro)
+    finally:
+        # Clean up completed/cancelled tasks so residual CancelledError
+        # doesn't leak to next run
+        _reap_done_tasks(evloop)
+

pyaml_cs_oa-0.1.0/pyaml_cs_oa/container.py

@@ -0,0 +1,170 @@
+import asyncio
+import inspect
+from collections.abc import Awaitable, Callable
+from typing import TypeVar
+from .signal import OASignal
+
+from ophyd_async.core import (
+    SignalDatatypeT,
+    SignalR,
+    SignalW,
+    set_and_wait_for_other_value,
+)
+
+T = TypeVar("T")
+
+from . import arun
+
+def _looks_disconnected(exc: BaseException) -> bool:
+    # Keep it generic: ophyd-async wraps cancellations in TimeoutError;
+    # tango/epics transports often raise CancelledError or "NotConnected" types.
+    return isinstance(exc, (asyncio.CancelledError, TimeoutError))
+
+
+async def _recover_once(
+    run: Callable[[], Awaitable[T]],
+    reconnect: Callable[[], Awaitable[None]],
+    peer: OASignal,
+) -> T:
+    try:
+        return await run()
+    except BaseException as exc:
+        if not _looks_disconnected(exc):
+            raise
+        # Attempt reconnect of the same Signal first
+        try:
+            await reconnect()
+            return await run()
+        except BaseException:
+            # If that fails and we have a way to rebuild, do so and try one more time
+            if peer is not None:
+                maybe_awaitable = peer.build()
+                if inspect.isawaitable(maybe_awaitable):
+                    await maybe_awaitable
+                await reconnect()
+                return await run()
+            raise
+
+
+class OAReadback():
+    """A readback object."""
+
+    def __init__(self, r_signal: SignalR[SignalDatatypeT]):
+        self._r_sig = r_signal
+
+    async def _run_get(self) -> SignalDatatypeT:
+        await self._r_sig.connect()
+        backend = self._r_sig._connector.backend
+        return await backend.get_value()
+
+    async def async_get(self) -> SignalDatatypeT:
+        return await _recover_once(
+            self._run_get,
+            self._r_sig.connect,
+            getattr(self._r_sig, "__peer__", None),
+        )
+
+    async def _run_read(self) -> SignalDatatypeT:
+        await self._r_sig.connect()
+        backend = self._r_sig._connector.backend
+        return await backend.get_reading()
+
+    async def async_read(self) -> SignalDatatypeT:
+        return await _recover_once(
+            self._run_read,
+            self._r_sig.connect,
+            getattr(self._r_sig, "__peer__", None),
+        )
+
+    def get(self) -> SignalDatatypeT:
+        """Synchronous wrapper around `async_get()`."""
+        return arun(self.async_get())
+
+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)
+
+    async def _run_get(self) -> SignalDatatypeT:
+        await self._w_sig.connect()
+        backend = self._w_sig._connector.backend
+        return await backend.get_setpoint()
+
+    async def async_get(self) -> SignalDatatypeT:
+        return await _recover_once(
+            self._run_get,
+            self._w_sig.connect,
+            getattr(self._w_sig, "__peer__", None),
+        )
+
+    async def _run_read(self) -> SignalDatatypeT:
+        await self._w_sig.connect()
+        backend = self._w_sig._connector.backend
+        return await backend.get_reading()
+
+    async def async_read(self) -> SignalDatatypeT:
+        return await _recover_once(
+            self._run_read,
+            self._w_sig.connect,
+            getattr(self._w_sig, "__peer__", None),
+        )
+
+    async def _run_set(self, value):
+        await self._w_sig.connect()
+        status = self._w_sig.set(value)
+        return status
+
+    async def async_set(self, value):
+        return await _recover_once(
+            lambda: self._run_set(value),
+            self._w_sig.connect,
+            getattr(self._w_sig, "__peer__", None),
+        )
+
+    async def _reconnect_both(self) -> None:
+        await asyncio.gather(self._w_sig.connect(), self._r_sig.connect())
+
+    async def _rebuild_both(self) -> None:
+        w_rebuild = getattr(self._w_sig, "__peer__", None)
+        r_rebuild = getattr(self._r_sig, "__peer__", None)
+        if w_rebuild is not None:
+            w_rebuild()
+        if r_rebuild is not None:
+            r_rebuild()
+
+    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."
+            )
+        await self._reconnect_both()
+        await set_and_wait_for_other_value(self._w_sig, value, self._r_sig, value)
+
+    async def async_set_and_wait(self, value) -> None:
+        return await _recover_once(
+            lambda: self._run_set_and_wait(value),
+            self._reconnect_both,
+            self._rebuild_both,
+        )
+
+    async def _complete_set(self, value):
+            status = await self.async_set(value)
+            await status  # Wait for completion before returning
+            return status
+
+    def set(self, value):
+        """Synchronous wrapper around `async_set()`."""
+        return arun(self._complete_set(value))
+
+    def get(self) -> SignalDatatypeT:
+        """Synchronous wrapper around `async_get()`."""
+        return arun(self.async_get())
+
+    def set_and_wait(self, value) -> None:
+        """Synchronous wrapper around `async_set_and_wait()`."""
+        return arun(self.async_set_and_wait(value))

pyaml_cs_oa-0.1.0/pyaml_cs_oa/controlsystem.py

@@ -0,0 +1,154 @@
+import os
+import logging
+import copy
+
+from pyaml.control.controlsystem import ControlSystem
+from pydantic import BaseModel
+from pyaml.common.exception import PyAMLException
+
+PYAMLCLASS : str = "OphydAsyncControlSystem"
+
+logger = logging.getLogger(__name__)
+
+from .types import (
+    EpicsConfigR,
+    EpicsConfigW,
+    EpicsConfigRW,
+    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
+
+class ConfigModel(BaseModel):
+
+    """
+    Configuration model for an OA Control System.
+
+    Attributes
+    ----------
+    name : str
+        Name of the control system.
+    prefix : str
+        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. 
+    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
+    scalar_aggregator: str | None = "pyaml_cs_oa.scalar_aggregator"
+    vector_aggregator: str | None = None
+
+
+class OphydAsyncControlSystem(ControlSystem):
+    """A generic control system using ophyd_async backend."""
+
+    def __init__(self, cfg: ConfigModel):
+        super().__init__()
+        self._cfg = cfg
+        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)
+
+        logger.log(logging.WARNING, f"OA control system binding for PyAML 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)
+
+    def attach_array(self, devs: list[OASignal]) -> list[OASignal]:
+        return self._attach(devs,True)
+
+    def _attach(self, devs: list[OASignal],is_array:bool) -> list[OASignal]:
+        # Concatenate the prefix
+        newDevs = []
+        for d in devs:            
+            if d is not None:
+
+                sig_cfg = d._cfg
+                sig_cfg_cls = sig_cfg.__class__
+                
+                if isinstance(d._cfg,EpicsConfigR):
+                    key = self._cfg.prefix + d._cfg.read_pvname
+                    sig_cls = EpicsR
+                    config = dict(read_pvname=key,timeout_ms=d._cfg.timeout_ms)
+                elif isinstance(d._cfg,EpicsConfigW):
+                    key = self._cfg.prefix + d._cfg.write_pvname
+                    sig_cls = EpicsW
+                    config = dict(write_pvname=key,timeout_ms=d._cfg.timeout_ms)
+                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,timeout_ms=d._cfg.timeout_ms)
+                elif isinstance(d._cfg,TangoConfigR):
+                    key = self._cfg.prefix + d._cfg.attribute
+                    sig_cls = TangoR
+                    config = dict(attribute=key,timeout_ms=d._cfg.timeout_ms)
+                elif isinstance(d._cfg,TangoConfigRW):
+                    key = self._cfg.prefix + d._cfg.attribute
+                    sig_cls = TangoRW
+                    config = dict(attribute=key,timeout_ms=d._cfg.timeout_ms)
+                else:
+                    raise PyAMLException(f"OphydAsyncControlSystem: Unsupported type {type(sig_cfg)}")
+
+                if key not in self._devices:
+                    nr = sig_cls(sig_cfg_cls(**config),is_array)
+                    nr.build()
+                    self._devices[key] = nr
+
+                newDevs.append(self._devices[key])
+            else:
+                newDevs.append(None)
+        return newDevs
+
+    def name(self) -> str:
+        """
+        Return the name of the control system.
+
+        Returns
+        -------
+        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
+
+        Returns
+        -------
+        str
+            Aggregator module name
+        """
+        return self._cfg.scalar_aggregator
+
+    def vector_aggregator(self) -> str | None:
+        """
+        Returns the module name used for handling aggregator of DeviceVectorAccess
+        
+        Returns
+        -------
+        str
+            Aggregator module name
+        """
+        return self._cfg.vector_aggregator
+
+    def __repr__(self):
+       return repr(self._cfg).replace("ConfigModel",self.__class__.__name__)

pyaml_cs_oa-0.1.0/pyaml_cs_oa/epics.py

@@ -0,0 +1,53 @@
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_w, epics_signal_rw
+from ophyd_async.core import Array1D
+import numpy
+
+from .container import OAReadback as Readback
+from .container import OASetpoint as Setpoint
+from .types import (
+    ControlSysConfig,
+    EpicsConfigR,
+    EpicsConfigRW,
+    EpicsConfigW,
+)
+
+
+def get_SP_RB(cfg: ControlSysConfig,is_array:bool) -> tuple[Setpoint | None, Readback | None]:
+    setpoint: Setpoint | None = None
+    readback: Readback | None = None
+
+    assert isinstance(cfg, (EpicsConfigRW, EpicsConfigR, EpicsConfigW))
+
+    if isinstance(cfg, EpicsConfigR):
+        r_sig = epics_signal_r(
+            datatype=float if not is_array else Array1D[numpy.float64],
+            read_pv=cfg.read_pvname,
+            name="",
+            timeout = cfg.timeout_ms / 1000.,
+        )
+        readback = Readback(r_sig)
+        setpoint = None
+
+    if isinstance(cfg, EpicsConfigW):
+        w_sig = epics_signal_w(
+            datatype=float if not is_array else Array1D[numpy.float64],
+            write_pv=cfg.write_pvname,
+            name="",
+            timeout = cfg.timeout_ms / 1000.,
+        )
+        readback = None
+        setpoint = Setpoint(w_sig)
+
+    if isinstance(cfg, EpicsConfigRW):
+        w_sig = epics_signal_rw(
+            datatype=float if not is_array else Array1D[numpy.float64],
+            read_pv=cfg.read_pvname,
+            write_pv=cfg.write_pvname,
+            name="",
+            timeout = cfg.timeout_ms / 1000.,
+        )
+        readback = Readback(w_sig)
+        setpoint = Setpoint(w_sig)
+
+
+    return setpoint, readback

pyaml_cs_oa-0.1.0/pyaml_cs_oa/epicsR.py

@@ -0,0 +1,13 @@
+from .float_signal import FloatSignalContainer
+from .types import EpicsConfigR
+
+PYAMLCLASS : str = "EpicsR"
+
+class ConfigModel(EpicsConfigR):
+    unit: str = ""
+
+class EpicsR(FloatSignalContainer):
+    def __init__(self, cfg: ConfigModel, is_array=False):
+        super().__init__(cfg,is_array)
+    def get_cs(self) -> str:
+        return "epics"        

pyaml_cs_oa-0.1.0/pyaml_cs_oa/epicsRW.py

@@ -0,0 +1,13 @@
+from .float_signal import FloatSignalContainer
+from .types import EpicsConfigRW
+
+PYAMLCLASS : str = "EpicsRW"
+
+class ConfigModel(EpicsConfigRW):
+    unit: str = ""
+
+class EpicsRW(FloatSignalContainer):
+    def __init__(self, cfg: ConfigModel, is_array=False):
+        super().__init__(cfg,is_array)
+    def get_cs(self) -> str:
+        return "epics"