nbs-bl 0.2.0__py3-none-any.whl

nbs_bl/qt/widgets/energy.py

@@ -0,0 +1,225 @@
+from qtpy.QtWidgets import (
+    QGroupBox,
+    QVBoxLayout,
+    QHBoxLayout,
+    QComboBox,
+    QPushButton,
+    QMessageBox,
+    QDialog,
+)
+from nbs_gui.views.views import AutoControl, AutoMonitor
+from nbs_gui.views.motor import MotorMonitor
+from bluesky_queueserver_api import BPlan
+from nbs_gui.settings import get_top_level_model
+
+
+class EnergyMonitor(QGroupBox):
+    """Display widget for monitoring energy-related components.
+
+    Parameters
+    ----------
+    energy : object
+        Energy model containing energy, gap, and phase attributes
+    parent_model : object
+        Parent model containing beamline configuration
+    orientation : str, optional
+        Layout orientation
+    *args, **kwargs
+        Additional arguments passed to QGroupBox
+    """
+
+    def __init__(self, energy, parent_model, *args, orientation=None, **kwargs):
+        print("Initializing EnergyMonitor")
+        super().__init__("Energy Monitor", *args, **kwargs)
+        self.model = energy
+        self.top_level_model = get_top_level_model()
+        self.beamline_model = self.top_level_model.beamline
+        vbox1 = QVBoxLayout()
+
+        print("Adding energy monitor")
+        vbox1.addWidget(AutoMonitor(self.model.energy, parent_model))
+
+        has_slits = (
+            hasattr(self.beamline_model, "slits")
+            and self.beamline_model.slits is not None
+        )
+        if has_slits:
+            print("Adding slits monitor")
+            vbox1.addWidget(AutoMonitor(self.beamline_model.slits, parent_model))
+
+        print("Adding CFF monitor")
+        vbox1.addWidget(AutoMonitor(self.model.cff, parent_model))
+
+        print("Adding grating motor monitor")
+        if hasattr(self.model, "grating_motor"):
+            vbox1.addWidget(MotorMonitor(self.model.grating_motor, parent_model))
+
+        self.setLayout(vbox1)
+        print("EnergyMonitor initialization complete")
+
+
+class EnergyControl(QGroupBox):
+    """Widget for controlling energy-related components.
+
+    Parameters
+    ----------
+    energy : object
+        Energy model containing energy, gap, and phase attributes
+    parent_model : object
+        Parent model containing beamline configuration
+    orientation : str, optional
+        Layout orientation
+    *args, **kwargs
+        Additional arguments passed to QGroupBox
+    """
+
+    def __init__(self, energy, parent_model, *args, orientation=None, **kwargs):
+        print("Initializing EnergyControl")
+        super().__init__("Energy Control", *args, **kwargs)
+
+        self.model = energy
+        self.parent_model = parent_model
+        top_model = get_top_level_model()
+        self.REClientModel = top_model.run_engine
+
+        print("Creating Energy Control layout")
+        hbox = QHBoxLayout()
+        ebox = QVBoxLayout()
+        hbox2 = QHBoxLayout()
+
+        print("Adding energy control")
+        if hasattr(energy, "energy"):
+            hbox.addWidget(AutoControl(energy.energy, parent_model))
+
+        has_slits = (
+            hasattr(top_model.beamline, "slits")
+            and top_model.beamline.slits is not None
+        )
+        if has_slits:
+            print("Adding exit slit control")
+            ebox.addWidget(AutoControl(top_model.beamline.slits, parent_model))
+
+        print("Adding CFF and grating monitors")
+        if hasattr(energy, "cff"):
+            hbox2.addWidget(AutoMonitor(energy.cff, parent_model))
+        if hasattr(energy, "grating_motor"):
+            hbox2.addWidget(AutoMonitor(energy.grating_motor, parent_model))
+
+        self.advancedControlButton = QPushButton("Advanced Controls")
+        self.advancedControlButton.clicked.connect(self.showAdvancedControls)
+        hbox2.addWidget(self.advancedControlButton)
+        ebox.addLayout(hbox2)
+        hbox.addLayout(ebox)
+        self.setLayout(hbox)
+        print("EnergyControl initialization complete")
+
+    def showAdvancedControls(self):
+        """Show the Advanced Energy Control dialog."""
+        print("Opening advanced controls dialog")
+        self.advancedDialog = QDialog(self)
+        self.advancedDialog.setWindowTitle("Advanced Energy Control")
+        layout = QVBoxLayout()
+        advancedControl = AdvancedEnergyControl(
+            self.model, self.parent_model, self.advancedDialog
+        )
+        layout.addWidget(advancedControl)
+        self.advancedDialog.setLayout(layout)
+        self.advancedDialog.exec_()
+
+
+class AdvancedEnergyControl(QGroupBox):
+    """Advanced controls for energy-related components.
+
+    Parameters
+    ----------
+    model : object
+        Energy model containing energy, gap, and phase attributes
+    parent_model : object
+        Parent model containing beamline configuration
+    parent : QWidget, optional
+        Parent widget
+    """
+
+    def __init__(self, model, parent_model, parent=None):
+        print("Initializing AdvancedEnergyControl")
+        super().__init__("Advanced Energy Control", parent)
+        self.model = model
+        self.parent_model = parent_model
+        top_model = get_top_level_model()
+        self.REClientModel = top_model.run_engine
+
+        layout = QVBoxLayout()
+
+        print("Adding CFF control")
+        if hasattr(model, "cff"):
+            layout.addWidget(AutoControl(model.cff, parent_model))
+
+        print("Creating grating controls")
+        hbox = QHBoxLayout()
+        if hasattr(model, "grating_motor"):
+            hbox.addWidget(MotorMonitor(model.grating_motor, parent_model))
+
+            print("Setting up grating selection")
+            cb = QComboBox()
+            self.cb = cb
+            if hasattr(model.grating_motor.obj.setpoint, "enum_strs"):
+                for n, s in enumerate(model.grating_motor.obj.setpoint.enum_strs):
+                    if s != "":
+                        cb.addItem(s, n)
+
+            self.button = QPushButton("Change Grating")
+            self.button.clicked.connect(self.change_grating)
+            hbox.addWidget(cb)
+            hbox.addWidget(self.button)
+
+            self.tuneButton = QPushButton("Tune grating offsets")
+            self.tuneButton.clicked.connect(self.tune_grating)
+            hbox.addWidget(self.tuneButton)
+
+        layout.addLayout(hbox)
+        self.setLayout(layout)
+        print("AdvancedEnergyControl initialization complete")
+
+    def tune_grating(self):
+        """Execute grating tuning plan."""
+        print("Initiating grating tune")
+        msg = "Ensure beamline is opened to multimesh reference ladder for tune"
+        if self.confirm_dialog(msg):
+            plan = BPlan("tune_grating")
+            self.REClientModel._client.item_execute(plan)
+
+    def change_grating(self):
+        """Execute grating change plan."""
+        print("Initiating grating change")
+        enum = self.cb.currentData()
+        print(f"Selected grating enum: {enum}")
+        msg = (
+            "Are you sure you want to change gratings?\n"
+            "Ensure beam is open to the multimesh.\n"
+            "Grating change and tune will run as queue item"
+        )
+        if self.confirm_dialog(msg):
+            plan = BPlan("change_grating", enum)
+            self.REClientModel._client.item_execute(plan)
+
+    def confirm_dialog(self, confirm_message):
+        """Show a confirmation dialog.
+
+        Parameters
+        ----------
+        confirm_message : str
+            Message to display in the dialog
+
+        Returns
+        -------
+        bool
+            True if user confirmed, False otherwise
+        """
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Question)
+        msg.setText(confirm_message)
+        msg.setStyleSheet("button-layout: 1")
+        msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
+        msg.setDefaultButton(QMessageBox.No)
+        ret = msg.exec_()
+        return ret == QMessageBox.Yes

nbs_bl/queueserver.py

@@ -0,0 +1,249 @@
+from .status import StatusDict, StatusContainerBase, RedisStatusDict, StatusList
+from collections import abc
+from ophyd import OphydObject
+import redis
+
+
+class GlobalStatusManager:
+    """
+    Manager class for handling global status dictionaries and lists with Redis connections
+
+    Parameters
+    ----------
+    redis_host : str, optional
+        Redis server hostname, by default 'localhost'
+    redis_port : int, optional
+        Redis server port, by default 6379
+    """
+
+    def __init__(self, redis_host="localhost", redis_port=6379):
+        self._status_dict = StatusDict()
+        self._redis_client = None
+        self._redis_host = redis_host
+        self._redis_port = redis_port
+        self._global_prefix = None
+
+    def init_redis(self, host=None, port=None, db=0, global_prefix="status:"):
+        """
+        Initialize Redis connection with optional new host/port and global prefix
+
+        Parameters
+        ----------
+        host : str, optional
+            Redis server hostname
+        port : int, optional
+            Redis server port
+        global_prefix : str, optional
+            Global prefix for all Redis keys, by default "status:"
+        """
+        if host is not None:
+            self._redis_host = host
+        if port is not None:
+            self._redis_port = port
+
+        self._global_prefix = global_prefix
+        print(f"Initializing redis Client with {host}, {port}, {db}")
+        self._redis_client = redis.Redis(
+            host=self._redis_host, port=self._redis_port, db=db
+        )
+        return self._redis_client
+
+    def add_status(self, key, container: StatusContainerBase):
+        """Add a status container to the manager"""
+        self._status_dict[key] = container
+
+    def remove_status(self, key):
+        """Remove a status container from the manager"""
+        del self._status_dict[key]
+
+    def get_status(self):
+        """Get dictionary of all status UIDs"""
+        return {k: str(v.get_uid()) for k, v in self._status_dict.items()}
+
+    def request_status_dict(self, key, use_redis=False, prefix=None):
+        """
+        Create and return a new status dictionary
+
+        Parameters
+        ----------
+        key : str
+            Key for the status dictionary
+        use_redis : bool, optional
+            If True, returns RedisStatusDict, otherwise StatusDict
+        prefix : str, optional
+            Additional prefix for Redis keys if using RedisStatusDict.
+            If None, uses the key as prefix.
+
+        Returns
+        -------
+        StatusDict or RedisStatusDict
+            The requested status dictionary
+
+        Raises
+        ------
+        RuntimeError
+            If Redis is requested but not initialized
+        """
+        if use_redis:
+            if self._redis_client is None:
+                import warnings
+
+                warnings.warn(f"Redis not initialized. Using plain StatusDict for {key} instead.")
+                status_dict = StatusDict()
+            else:
+                # Construct the full prefix
+                if prefix is None:
+                    prefix = key
+                full_prefix = f"{self._global_prefix}{prefix}"
+                status_dict = RedisStatusDict(self._redis_client, prefix=full_prefix)
+        else:
+            status_dict = StatusDict()
+
+        self.add_status(key, status_dict)
+        return status_dict
+
+    def request_status_list(self, key, use_redis=False):
+        """
+        Request a new status list, optionally backed by Redis
+
+        Parameters
+        ----------
+        key : str
+            Key for the status list
+        use_redis : bool, optional
+            If True, creates list in RedisStatusDict, otherwise returns plain StatusList
+
+        Returns
+        -------
+        StatusList
+            The requested status list
+
+        Notes
+        -----
+        When using Redis, the list is stored in a RedisStatusDict using the global prefix,
+        with the provided key used as the dictionary key for the list.
+        """
+        if use_redis:
+            if self._redis_client is None:
+                import warnings
+
+                warnings.warn(f"Redis not initialized. Using plain StatusList for {key} instead.")
+                status_list = StatusList()
+            else:
+                # Create or get the Redis dict with only global prefix
+                redis_dict = self._get_or_create_redis_dict()
+                # Create new status list
+                status_list = StatusList()
+                # Store in Redis dict under the given key
+                redis_dict[key] = status_list
+        else:
+            status_list = StatusList()
+
+        # Add to status manager
+        self.add_status(key, status_list)
+        return status_list
+
+    def _get_or_create_redis_dict(self):
+        """
+        Get or create the global RedisStatusDict for storing lists
+
+        Returns
+        -------
+        RedisStatusDict
+            The global Redis dictionary for storing lists
+        """
+        # Use a special key for the global Redis dict
+        global_dict_key = "_global_redis_dict"
+
+        if global_dict_key not in self._status_dict:
+            # Create new Redis dict with only global prefix
+            redis_dict = RedisStatusDict(self._redis_client, prefix=self._global_prefix)
+            self.add_status(global_dict_key, redis_dict)
+
+        return self._status_dict[global_dict_key]
+
+    def keys(self):
+        return self._status_dict.keys()
+
+    def __getitem__(self, key):
+        return self._status_dict[key]
+
+    def __setitem__(self, key, value):
+        self.add_status(key, value)
+
+    def __delitem__(self, key):
+        self.remove_status(key)
+
+    def __contains__(self, key):
+        return key in self._status_dict
+
+    def request_update(self, key):
+        """Request an update for a specific status key"""
+        if key in self._status_dict:
+            sbuffer = self._status_dict[key]
+            if isinstance(sbuffer, abc.Sequence):
+                return represent_sequence(sbuffer)
+            if isinstance(sbuffer, abc.Mapping):
+                return represent_mapping(sbuffer)
+            if isinstance(sbuffer, abc.Set):
+                return represent_set(sbuffer)
+
+
+# Create global instance
+GLOBAL_USER_STATUS = GlobalStatusManager()
+
+
+def request_update(key):
+    return GLOBAL_USER_STATUS.request_update(key)
+
+
+def get_status():
+    return GLOBAL_USER_STATUS.get_status()
+
+
+# Keep existing helper functions
+def represent_item(item):
+    if isinstance(item, OphydObject):
+        return item.name
+    elif isinstance(item, abc.Sequence):
+        return represent_sequence(item)
+    elif isinstance(item, abc.Mapping):
+        return represent_mapping(item)
+    elif isinstance(item, abc.Set):
+        return represent_set(item)
+    else:
+        return item
+
+
+def represent_mapping(m):
+    rep = {}
+    for k, v in m.items():
+        rep[k] = represent_item(v)
+    return rep
+
+
+def represent_sequence(s):
+
+    if isinstance(s, str):
+        return s
+    else:
+        rep = []
+        for v in s:
+            rep.append(represent_item(v))
+        return rep
+
+
+def represent_set(s):
+    return represent_sequence(s)
+
+
+def print_mapping(m):
+    return str(represent_mapping(m))
+
+
+def print_sequence(s):
+    return str(represent_sequence(s))
+
+
+def print_set(s):
+    return str(represent_set(s))

nbs_bl/redisDevice.py

@@ -0,0 +1,96 @@
+import json
+from ophyd.signal import Signal
+from ophyd.device import Device, Component as Cpt
+
+
+
+class _RedisSignal(Signal):
+    """
+    Minimal signal-like wrapper around a Redis-backed USER_STATUS entry.
+
+    Parameters
+    ----------
+    dict_name : str
+        Name of the USER_STATUS dictionary to access.
+    key : str
+        Key within the dictionary.
+    default : any
+        Default value to use if key is missing.
+    """
+    default_status_provider = None
+
+    @classmethod
+    def set_default_status_provider(cls, provider):
+        cls.default_status_provider = provider
+
+    def __init__(self, *, dict_name=None, default=None, **kwargs):
+        super().__init__(**kwargs)
+        parent_prefix = getattr(self.parent, "prefix", None)
+        resolved_dict = dict_name or parent_prefix
+        if not resolved_dict:
+            raise ValueError("RedisSignal requires a dict_name or parent prefix")
+        self._dict_name = resolved_dict
+        self._key = self.name
+        self._default = default
+        provider = self._status_provider()
+        if self._dict_name not in provider:
+            provider.request_status_dict(self._dict_name, use_redis=True)
+        self._ensure_key_exists()
+
+    def _ensure_key_exists(self):
+        dct = self._status_provider()[self._dict_name]
+        if self._key not in dct:
+            dct[self._key] = self._default
+
+    def get(self, **kwargs):
+        try:
+            dct = self._status_provider()[self._dict_name]
+            return dct.get(self._key, self._default)
+        except Exception as e:
+            print(f"RedisSignal get error for {self._dict_name}:{self._key}: {e}")
+            return self._default
+
+    def put(self, value, **kwargs):
+        try:
+            dct = self._status_provider()[self._dict_name]
+            dct[self._key] = value
+            # Notify subscribers
+            self._run_subs(sub_type=self.SUB_VALUE, value=value, **kwargs)
+            return value
+        except Exception as e:
+            print(f"RedisSignal put error for {self._dict_name}:{self._key}: {e}")
+            return self._default
+
+    def _status_provider(self):
+        provider = getattr(self, "_provider", None) or _RedisSignal.default_status_provider
+        if provider is None:
+            raise RuntimeError("No status provider configured for RedisDevice")
+        return provider
+
+def RedisDevice(prefix, name="", keys=None, status_provider=None, **kwargs):
+    """
+    Factory function to create a Redis-backed Device with one Component per key.
+    """
+    keys = keys or {}
+
+    attrs = {
+        "_keys_config": keys,
+        "_dict_name": None,
+        "_status_provider": status_provider or _RedisSignal.default_status_provider,
+    }
+    for key, default in keys.items():
+        attrs[key] = Cpt(_RedisSignal, name=key, default=default)
+
+    cls = type(f"RedisDevice_{name}", (Device,), attrs)
+    obj = cls(prefix=prefix, name=name, **kwargs)
+
+
+    return obj
+
+class RedisModeDevice(Device):
+
+    mode = Cpt(_RedisSignal, name="mode", default="default")
+
+    def __init__(self, prefix, name="", status_provider=None, **kwargs):
+        super().__init__(prefix=prefix, name=name, **kwargs)
+        self._status_provider = status_provider

nbs_bl/run_engine.py

@@ -0,0 +1,63 @@
+import asyncio
+from bluesky import RunEngine
+from .beamline import GLOBAL_BEAMLINE
+from bluesky_queueserver import is_re_worker_active
+
+
+async def generic_cmd(msg):
+    """
+    Generic command handler for all commands
+    """
+    command, obj, args, kwargs, _ = msg
+    ret = getattr(obj, command)(*args, **kwargs)
+    return ret
+
+
+async def call_obj(msg):
+    """
+    Call an object's method
+    """
+    obj = msg.obj
+    kwargs = msg.kwargs
+    args = msg.args
+    command = kwargs.pop("method")
+    ret = getattr(obj, command)(*args, **kwargs)
+    return ret
+
+
+async def _update_plan_status(msg):
+    """
+    Update the plan status
+    """
+    command, obj, args, kwargs, _ = msg
+    GLOBAL_BEAMLINE.plan_status["status"] = args[0]
+
+
+async def _clear_plan_status(msg):
+    """
+    Clear the plan status
+    """
+    command, obj, args, kwargs, _ = msg
+    GLOBAL_BEAMLINE.plan_status["status"] = "idle"
+
+
+def load_RE_commands(engine):
+    engine.register_command("call_obj", call_obj)
+    engine.register_command("update_plan_status", _update_plan_status)
+    engine.register_command("clear_plan_status", _clear_plan_status)
+
+
+def setup_run_engine(RE):
+    load_RE_commands(RE)
+    RE.preprocessors.append(GLOBAL_BEAMLINE.supplemental_data)
+    return RE
+
+
+def create_run_engine(setup=True):
+    if is_re_worker_active():
+        RE = RunEngine(call_returns_result=False)
+    else:
+        RE = RunEngine(call_returns_result=True)
+    if setup:
+        setup_run_engine(RE)
+    return RE