nbs-bl 0.2.0__py3-none-any.whl

nbs_bl/startup.py

@@ -0,0 +1,27 @@
+from bluesky.plan_stubs import abs_set, mv
+import nbs_bl
+from nbs_bl.hw import *
+from nbs_bl.detectors import (
+    list_detectors,
+    activate_detector,
+    deactivate_detector,
+    activate_detector_set,
+)
+from nbs_bl.motors import list_motors
+import nbs_bl.plans.scans
+
+from nbs_bl.run_engine import setup_run_engine, create_run_engine
+
+from nbs_bl.plans.groups import group
+from nbs_bl.plans.plan_stubs import set_exposure
+from nbs_bl.queueserver import request_update, get_status
+from nbs_bl.samples import list_samples
+from nbs_bl.beamline import GLOBAL_BEAMLINE
+
+
+print("NBS Startup")
+
+RE(set_exposure(1.0))
+
+# load_saved_configuration()
+activate_detector_set("default")

nbs_bl/status.py

@@ -0,0 +1,114 @@
+import uuid
+from abc import ABC, abstractmethod
+from redis_json_dict import RedisJSONDict
+
+
+class StatusContainerBase(ABC):
+
+    @classmethod
+    @property
+    @abstractmethod
+    def NORMAL_METHODS(cls):
+        raise NotImplementedError
+
+    @classmethod
+    @property
+    @abstractmethod
+    def REINIT_METHODS(cls):
+        raise NotImplementedError
+
+    @classmethod
+    def _make_normal_method(cls, method):
+        def _inner(self, *args):
+            self._uid = uuid.uuid4()
+            return getattr(super(), method)(*args)
+
+        _inner.__name__ = method
+        setattr(cls, method, _inner)
+
+    @classmethod
+    def _make_reinit_method(cls, method):
+        def _inner(self, *args):
+            self._uid = uuid.uuid4()
+            newitem = getattr(super(), method)(*args)
+            return self.__class__(newitem)
+
+        _inner.__name__ = method
+        setattr(cls, method, _inner)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._uid = uuid.uuid4()
+        for method in self.NORMAL_METHODS:
+            self.__class__._make_normal_method(method)
+
+        for method in self.REINIT_METHODS:
+            self.__class__._make_reinit_method(method)
+
+    def get_uid(self):
+        return self._uid
+
+
+class StatusList(StatusContainerBase, list):
+    NORMAL_METHODS = [
+        "__delitem__",
+        "__setitem__",
+        "append",
+        "clear",
+        "extend",
+        "insert",
+        "pop",
+        "remove",
+    ]
+    REINIT_METHODS = ["__rmul__", "__iadd__", "__add__", "__imul__", "__mul__"]
+
+
+class StatusDict(StatusContainerBase, dict):
+    NORMAL_METHODS = ["__delitem__", "__setitem__", "clear", "pop", "update"]
+    REINIT_METHODS = ["__or__", "__ror__"]
+
+
+class StatusTuple(StatusContainerBase, tuple):
+    NORMAL_METHODS = []
+    REINIT_METHODS = ["__add__", "__mul__", "__rmul__"]
+
+    def __init__(self, *args, **kwargs):
+        self._uid = uuid.uuid4()
+        for method in self.NORMAL_METHODS:
+            self.__class__._make_normal_method(method)
+
+        for method in self.REINIT_METHODS:
+            self.__class__._make_reinit_method(method)
+
+
+class StatusSet(StatusContainerBase, set):
+    NORMAL_METHODS = [
+        "clear",
+        "pop",
+        "add",
+        "remove",
+        "update",
+        "discard",
+        "intersection_update",
+        "symmetric_difference_update",
+    ]
+    REINIT_METHODS = [
+        "__and__",
+        "__iand__",
+        "__rand__",
+        "__or__",
+        "__ior__",
+        "__ixor__",
+        "__xor__",
+        "__ror__",
+        "__rxor__",
+        "intersection",
+        "difference",
+        "union",
+        "symmetric_difference",
+    ]
+
+
+class RedisStatusDict(StatusContainerBase, RedisJSONDict):
+    NORMAL_METHODS = ["__delitem__", "__setitem__", "clear", "pop", "update"]
+    REINIT_METHODS = []

nbs_bl/tests/modify_regions.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""
+Script to modify test_regions.toml by swapping the order of energy and step values
+in each region array.
+
+The original format is: [energy1, energy2, step1, energy3, step2, ...]
+The new format will be: [energy1, step1, energy2, step2, energy3, ...]
+"""
+
+import argparse
+import re
+from pathlib import Path
+
+
+def modify_region_array(region_list):
+    """
+    Modify a region array by swapping the order of energy and step values.
+
+    Parameters
+    ----------
+    region_list : list
+        List of alternating energy and step values
+
+    Returns
+    -------
+    list
+        Modified list with energy and step values reordered
+    """
+    if len(region_list) < 3:
+        return region_list  # Need at least 3 values to swap
+
+    # The pattern is: [energy1, energy2, step1, energy3, step2, ...]
+    # We want: [energy1, step1, energy2, step2, energy3, ...]
+
+    result = [region_list[0]]  # Keep first energy value
+
+    # Process remaining values in pairs
+    for i in range(1, len(region_list) - 1, 2):
+        if i + 1 < len(region_list):
+            # Swap: energy, step -> step, energy
+            result.append(region_list[i + 1])  # step
+            result.append(region_list[i])  # energy
+
+    return result
+
+
+def modify_toml_content(content):
+    """
+    Modify TOML content by finding and modifying region arrays.
+
+    Parameters
+    ----------
+    content : str
+        Original TOML content
+
+    Returns
+    -------
+    str
+        Modified TOML content
+    """
+
+    # Use regex to find region arrays and modify them
+    def replace_region_array(match):
+        # Extract the array content
+        array_str = match.group(1)
+
+        # Parse the array values
+        # Remove brackets and split by commas
+        values_str = array_str.strip("[]")
+        values = []
+
+        # Simple parsing - split by comma and strip whitespace
+        for val in values_str.split(","):
+            val = val.strip()
+            if val:
+                # Try to convert to float/int, otherwise keep as string
+                try:
+                    if "." in val:
+                        values.append(float(val))
+                    else:
+                        values.append(int(val))
+                except ValueError:
+                    values.append(val)
+
+        # Modify the array
+        modified_values = modify_region_array(values)
+
+        # Convert back to string
+        modified_str = "[" + ", ".join(str(v) for v in modified_values) + "]"
+        return f"region = {modified_str}"
+
+    # Find all region arrays and replace them
+    pattern = r"region = \[([^\]]+)\]"
+    modified_content = re.sub(pattern, replace_region_array, content)
+
+    return modified_content
+
+
+def parse_arguments():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Modify TOML region arrays by swapping energy and step values"
+    )
+    parser.add_argument(
+        "--input",
+        type=str,
+        default="test_regions.toml",
+        help="Input TOML file path (default: test_regions.toml)",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="test_regions_modified.toml",
+        help="Output TOML file path (default: test_regions_modified.toml)",
+    )
+    return parser.parse_args()
+
+
+def main():
+    """Main function to process the TOML file."""
+    args = parse_arguments()
+
+    # File paths
+    input_file = Path(args.input)
+    output_file = Path(args.output)
+
+    # Check if input file exists
+    if not input_file.exists():
+        print(f"Error: Input file {input_file} not found")
+        return
+
+    try:
+        # Read the original file
+        with open(input_file, "r") as f:
+            content = f.read()
+
+        print(f"Processing {input_file}...")
+
+        # Modify the content
+        modified_content = modify_toml_content(content)
+
+        # Write the modified content
+        with open(output_file, "w") as f:
+            f.write(modified_content)
+
+        print(f"Modified file written to {output_file}")
+
+        # Show an example of the transformation
+        print("\nExample transformation:")
+        original_example = [1055, 1065, 1.0, 1070, 0.2, 1080, 0.1, 1100, 0.2, 1140, 1.0]
+        print(f"Original: {original_example}")
+        modified_example = modify_region_array(original_example)
+        print(f"Modified: {modified_example}")
+
+    except Exception as e:
+        print(f"Error processing file: {e}")
+
+
+if __name__ == "__main__":
+    main()

nbs_bl/tests/test_frames.py

@@ -0,0 +1,99 @@
+import pytest
+import numpy as np
+from ..geometry.frames import Frame
+from ..geometry.linalg import vec
+
+
+@pytest.fixture
+def unit_frame():
+    p1 = vec(1, 0, 0)
+    p2 = vec(1, 0, 1)
+    p3 = vec(1, 1, 0)
+    unit_frame = Frame(p1, p2, p3)
+    return unit_frame
+
+
+@pytest.fixture
+def unit_frame90():
+    p1 = vec(1, 1, 0)
+    p2 = vec(1, 1, 1)
+    p3 = vec(0, 1, 0)
+    unit_frame90 = Frame(p1, p2, p3)
+    return unit_frame90
+
+
+@pytest.fixture
+def compound_frame():
+    pp1 = vec(1, 1, 0)
+    pp2 = vec(1, 1, 1)
+    pp3 = vec(1, 2, 0)
+    parent = Frame(pp1, pp2, pp3)
+
+    p1 = vec(0, 0, 0)
+    p2 = vec(0, 1, 0)
+    p3 = vec(0, 0, -1)
+    compound_frame = Frame(p1, p2, p3, parent=parent)
+    return compound_frame
+
+# Write compound test r0 -- figure out what it should mean
+
+
+@pytest.mark.parametrize("xoffset", [-1, 0, 1])
+@pytest.mark.parametrize("yoffset", [-1, 0, 1])
+@pytest.mark.parametrize("zoffset", [-1, 0, 1])
+def test_translated_frame(unit_frame, xoffset, yoffset, zoffset):
+    offset_vec = vec(xoffset, yoffset, zoffset)
+    p1 = vec(0, 0, 0) + offset_vec
+    p2 = vec(0, 1, 0) + offset_vec
+    p3 = vec(1, 0, 0) + offset_vec
+    compound = Frame(p1, p2, p3, parent=unit_frame)
+    parent_vec = unit_frame.frame_to_global(offset_vec, r=90,
+                                            rotation='global')
+    trans_vec = compound.frame_to_global(vec(0, 0, 0), r=90)
+    assert np.all(np.isclose(trans_vec, parent_vec))
+
+
+def test_unit_frame_roffset(unit_frame, unit_frame90):
+    assert unit_frame.r0 == 0
+    assert unit_frame90.r0 == 90
+
+
+def test_frame_to_global(unit_frame):
+    v_f = vec(0, 0, 0)
+    v_g = vec(1, 0, 0)
+    assert np.all(unit_frame.frame_to_global(v_f, rotation="global") == v_g)
+
+    v_f1 = vec(1, 0, 0)
+    v_g1 = vec(1, 1, 0)
+    assert np.all(unit_frame.frame_to_global(v_f1, rotation="global") == v_g1)
+
+    v_g2 = vec(0, 1, 0)
+    assert np.all(np.isclose(unit_frame.frame_to_global(v_f, r=90,
+                                                        rotation="frame"),
+                             v_g2))
+
+
+def test_compound_frame(unit_frame90, compound_frame):
+    v1 = vec(0, 0, 0)
+    vu1 = unit_frame90.frame_to_global(v1, rotation='global')
+    vc1 = compound_frame.frame_to_global(v1, rotation='global')
+    assert np.all(np.isclose(vu1, vc1))
+
+    v2 = vec(*np.random.rand(3))
+    vu2 = unit_frame90.frame_to_global(v2, rotation='global')
+    vc2 = compound_frame.frame_to_global(v2, rotation='global')
+    assert np.all(np.isclose(vu2, vc2))
+
+    r = 90*np.random.rand()
+    vu3 = unit_frame90.frame_to_global(v2, r=r, rotation='frame')
+    vc3 = compound_frame.frame_to_global(v2, r=r, rotation='frame')
+    assert np.all(np.isclose(vu3, vc3))
+
+    vu4 = unit_frame90.global_to_frame(v2, r=r)
+    vc4 = compound_frame.global_to_frame(v2, r=r)
+    assert np.all(np.isclose(vu4, vc4))
+
+    manip = vec(*np.random.rand(3))
+    vu5 = unit_frame90.global_to_frame(v2, manip=manip, r=r)
+    vc5 = compound_frame.global_to_frame(v2, manip=manip, r=r)
+    assert np.all(np.isclose(vu5, vc5))

nbs_bl/tests/test_panels.py

@@ -0,0 +1,69 @@
+import pytest
+import numpy as np
+from sst_base.frames import Panel
+from sst_base.linalg import vec
+
+
+@pytest.fixture()
+def unit_panel():
+    p1 = vec(1, 0, 0)
+    p2 = vec(1, 0, 1)
+    p3 = vec(-1, 0, 0)
+    height = 10
+    width = 2
+    panel = Panel(p1, p2, p3, width=width, height=height)
+    return panel
+
+
+@pytest.fixture()
+def rotated_panel():
+    p1 = vec(0, 0, 0)
+    p2 = vec(0, 0, 1)
+    p3 = vec(0, 1, 0)
+    height = 10
+    width = 2
+    panel = Panel(p1, p2, p3, width=width, height=height)
+    return panel
+
+
+def test_panel_position(unit_panel):
+    coords = np.array(unit_panel.beam_to_frame(0, 0, 0, 0))
+    assert np.all(coords == np.array([1, 0, 0, 90]))
+    coords = np.array(unit_panel.beam_to_frame(0, 0, 1, 0))
+    assert np.all(coords == np.array([1, -1, 0, 90]))
+    coords = np.array(unit_panel.beam_to_frame(1, 0, 1, 0))
+    assert np.all(coords == np.array([2, -1, 0, 90]))
+
+
+def test_panel_distance_sign_convention(unit_panel):
+    """
+    Tests that the distance is positive when the beam is outside the
+    panel, and negative when the beam is inside the panel
+    """
+    assert np.isclose(unit_panel.distance_to_beam(0, 0, 0, 0), 0)
+    assert unit_panel.distance_to_beam(0, 0, 1, 0) > 0
+    assert unit_panel.distance_to_beam(0, 0, -1, 0) < 0
+
+
+def test_panel_distance_from_edge(unit_panel):
+    assert np.isclose(unit_panel.distance_to_beam(0, 0, 0, 0), 0)
+    assert np.isclose(unit_panel.distance_to_beam(0, 0, 1, 0), 1)
+    assert np.isclose(unit_panel.distance_to_beam(0, 0, -0.5, 0), -0.5)
+    assert np.isclose(unit_panel.distance_to_beam(0, 0, -1, 0), -1)
+    assert np.isclose(unit_panel.distance_to_beam(0, 0, -2, 0), -1)
+    assert np.isclose(unit_panel.distance_to_beam(0, 0, -3, 0), -1)
+
+
+def test_panel_distance_from_corner(unit_panel):
+    assert np.isclose(unit_panel.distance_to_beam(-1, 0, 0, 0), 0)
+    assert np.isclose(unit_panel.distance_to_beam(-2, 0, -1, 0), 1)
+    assert np.isclose(unit_panel.distance_to_beam(-2, 0, 0, 0), 1)
+    assert np.isclose(unit_panel.distance_to_beam(-2, 0, 1, 0), np.sqrt(2))
+    assert np.isclose(unit_panel.distance_to_beam(-1, 0, 1, 0), 1)
+
+
+def test_edge_on_panel_distance(rotated_panel):
+    assert np.isclose(rotated_panel.distance_to_beam(0, 0, 0, 0), 0)
+    assert np.isclose(rotated_panel.distance_to_beam(0, 0, -1, 0), 0)
+    assert np.isclose(rotated_panel.distance_to_beam(0, 0, 1, 0), 1)
+    assert np.isclose(rotated_panel.distance_to_beam(1, 0, 1, 0), np.sqrt(2))

nbs_bl/utils.py

@@ -0,0 +1,235 @@
+import collections
+import inspect
+from functools import update_wrapper
+from numpydoc.docscrape import NumpyDocString, Parameter
+import copy
+
+
+def iterfy(x):
+    """
+    This function guarantees that a parameter passed will act like a list (or tuple) for the purposes of iteration,
+    while treating a string as a single item in a list.
+
+    Parameters
+    ----------
+    x : Any
+        The input parameter to be iterfied.
+
+    Returns
+    -------
+    Iterable
+        The input parameter as an iterable.
+    """
+    if isinstance(x, collections.abc.Iterable) and not isinstance(x, (str, bytes)):
+        return x
+    else:
+        return [x]
+
+
+def adjust_signature(*omit_args):
+    """
+    A decorator factory that adjusts the signature of the decorated function.
+    It omits specified arguments from the function's signature.
+
+    Parameters
+    ----------
+    *omit_args : str
+        Names of the arguments to be omitted from the function's signature.
+
+    Returns
+    -------
+    function
+        The decorated function with an adjusted signature.
+
+    Example
+    -------
+    @adjust_signature('arg_to_omit')
+    def func(arg_to_keep, arg_to_omit):
+        pass
+    """
+
+    def decorator(func):
+        sig = inspect.signature(func)
+        new_params = [p for name, p in sig.parameters.items() if name not in omit_args]
+        new_sig = sig.replace(parameters=new_params)
+        func.__signature__ = new_sig
+        return func
+
+    return decorator
+
+
+def merge_signatures(func):
+    def decorator(wrapper):
+        # Get the signatures of the two functions
+        sig_func = inspect.signature(func)
+        sig_wrapper = inspect.signature(wrapper)
+
+        # Separate positional and keyword parameters from variadic keyword parameters
+        func_params = list(sig_func.parameters.values())[1:]
+        wrapper_params = [
+            param
+            for param in sig_wrapper.parameters.values()
+            if param.kind != param.VAR_KEYWORD
+        ]
+        wrapper_var_keyword_params = [
+            param
+            for param in sig_wrapper.parameters.values()
+            if param.kind == param.VAR_KEYWORD
+        ]
+
+        # Create a new parameters list that includes parameters from both functions
+
+        new_params = (
+            wrapper_params
+            + [
+                param
+                for param in func_params
+                if param.name not in sig_wrapper.parameters
+            ]
+            + wrapper_var_keyword_params
+        )
+
+        # Create a new signature with the combined parameters
+        new_sig = sig_wrapper.replace(parameters=new_params)
+
+        # Update the signature of the wrapper function
+        wrapper.__signature__ = new_sig
+
+        # Update the docstring and other attributes of the wrapper function
+        update_wrapper(wrapper, func)
+
+        return wrapper
+
+    return decorator
+
+
+def merge_docstrings(doc1, doc2, omit_params=[], param_order=None):
+    """
+    Merge two numpy-style docstrings.
+
+    Parameters
+    ----------
+    doc1 : str
+        The first docstring.
+    doc2 : str
+        The second docstring.
+    omit_params : list of str
+        The names of parameters to omit from the final function signature and docstring.
+
+    Returns
+    -------
+    str
+        The merged docstring.
+    """
+    # Parse the docstrings
+    if doc1 is None:
+        doc1 = ""
+    if doc2 is None:
+        doc2 = ""
+    parsed_doc1 = NumpyDocString(doc1)
+    parsed_doc2 = NumpyDocString(doc2)
+
+    # Merge the parameters
+    params1 = {name: (typ, desc) for name, typ, desc in parsed_doc1["Parameters"]}
+    params2 = {name: (typ, desc) for name, typ, desc in parsed_doc2["Parameters"]}
+    params1.update(params2)
+    merged_params = [
+        Parameter(name, *params1[name]) for name in params1 if name not in omit_params
+    ]
+
+    # Sort the parameters so that any parameter with a "**" in its name is placed at the end
+    if param_order:
+        merged_params.sort(
+            key=lambda param: (
+                (
+                    param_order.index(param.name)
+                    if param.name in param_order
+                    else len(param_order)
+                ),
+                param.name,
+            )
+        )
+    else:
+        merged_params.sort(key=lambda param: "**" in param.name)
+
+    # Create a copy of the first parsed docstring
+    merged_doc = copy.deepcopy(parsed_doc1)
+
+    # Update the 'Parameters' section of the copied docstring
+    merged_doc["Parameters"] = merged_params
+
+    # Convert the merged docstring back to a string
+    return str(merged_doc)
+
+
+def sort_params(params):
+    params.sort(key=lambda param: param.default != inspect._empty)
+    params.sort(key=lambda param: param.kind)
+
+
+def merge_func(
+        func, omit_params=[], exclude_wrapper_args=True, exclude_wrapper_kwargs=True, use_func_name=True
+):
+    """
+    A decorator that merges the docstrings and function signatures of the wrapped function and the wrapper function.
+
+    Parameters
+    ----------
+    func : callable
+        The function to be wrapped.
+    omit_params : list of str
+        The names of parameters to omit from the final function signature and docstring.
+
+    Returns
+    -------
+    callable
+        The wrapper function with the merged docstring and function signature.
+    """
+
+    def decorator(wrapper):
+        # Merge the docstrings
+
+        # Merge the function signatures
+        sig_wrapper = inspect.signature(wrapper)
+        sig_func = inspect.signature(func)
+
+        # Get the parameters from the wrapper function and the wrapped function
+        params_wrapper = list(sig_wrapper.parameters.values())
+        if exclude_wrapper_args:
+            params_wrapper = [
+                param for param in params_wrapper if param.kind != param.VAR_POSITIONAL
+            ]
+        if exclude_wrapper_kwargs:
+            params_wrapper = [
+                param for param in params_wrapper if param.kind != param.VAR_KEYWORD
+            ]
+        params_func = [
+            param
+            for param in list(sig_func.parameters.values())
+            if param.name not in [wparam.name for wparam in params_wrapper]
+        ]
+        if params_func and params_func[0].name == "self":
+            params_func = params_func[1:]
+
+        combined_params = [
+            param
+            for param in params_func + params_wrapper 
+            if param.name not in omit_params
+        ]
+        sort_params(combined_params)
+        param_order = [param.name for param in combined_params]
+        merged_docstring = merge_docstrings(
+            wrapper.__doc__, func.__doc__, omit_params, param_order
+        )
+        wrapper.__doc__ = merged_docstring
+        # Create a new signature with the merged parameters
+        new_sig = sig_wrapper.replace(parameters=combined_params)
+
+        # Update the signature of the wrapper function
+        wrapper.__signature__ = new_sig
+        if use_func_name:
+            wrapper.__name__ = func.__name__
+
+        return wrapper
+
+    return decorator