nbs-bl 0.2.0__py3-none-any.whl

nbs_bl/geometry/polygons.py

@@ -0,0 +1,56 @@
+import numpy as np
+from .linalg import vec_len
+
+"""
+Module that computes areas, distances, and inclusion in polygons
+"""
+
+
+def triarea(p1, p2, p3):
+    n1 = p1 - p2
+    n2 = p3 - p2
+    return 0.5*(n1[0]*n2[1] - n1[1]*n2[0])
+
+
+def getPointAreas(p, *args):
+    areas = []
+    for n in range(len(args)):
+        areas.append(triarea(p, args[n-1], args[n]))
+    return areas
+
+
+def distFromTri(p, a, b):
+    area = np.abs(triarea(p, a, b))
+    d = vec_len(a - b)
+    s1 = vec_len(a - p)
+    s2 = vec_len(b - p)
+    if np.isclose(d, 0):
+        return min(s1, s2)
+    elif s1**2 > d**2 + s2**2:
+        return s2
+    elif s2**2 > d**2 + s1**2:
+        return s1
+    else:
+        return 2.0*area/d
+
+
+def getMinDist(p, *args):
+    distances = []
+    for n in range(len(args)):
+        distances.append(distFromTri(p, args[n-1], args[n]))
+    return np.min(distances)
+
+
+def prunePoints(*args):
+    pruned = []
+    for n in range(len(args)):
+        if not np.all(np.isclose(args[n-1] - args[n], 0.0)):
+            pruned.append(args[n])
+    return pruned
+
+
+def isInPoly(p, *args):
+    # Works for convex polygons only!
+    polyPoints = prunePoints(*args)
+    areas = np.array(getPointAreas(p, *polyPoints))
+    return (np.all(areas < 0) or np.all(areas > 0))

nbs_bl/help.py

@@ -0,0 +1,126 @@
+from .status import StatusList
+from .queueserver import GLOBAL_USER_STATUS
+from .printing import boxed_text
+
+GLOBAL_HELP_DICTIONARY = {
+    "functions": {},
+    "plans": {},
+    "scans": {},
+    "xas": {},
+    "conditions": {},
+}
+GLOBAL_IMPORT_DICTIONARY = {}
+
+# Request status lists from the global manager
+GLOBAL_PLAN_LIST = GLOBAL_USER_STATUS.request_status_list("PLAN_LIST", use_redis=True)
+GLOBAL_SCAN_LIST = GLOBAL_USER_STATUS.request_status_list("SCAN_LIST", use_redis=True)
+GLOBAL_CONDITION_LIST = GLOBAL_USER_STATUS.request_status_list(
+    "CONDITION_LIST", use_redis=True
+)
+GLOBAL_PLAN_TIME_DICT = GLOBAL_USER_STATUS.request_status_dict(
+    "PLAN_TIME_DICT", use_redis=True
+)
+
+
+def _add_to_import_list(f, help_section):
+    """
+    A function decorator that will add the function to the built-in list
+    """
+    key = f.__name__
+    doc = f.__doc__ if f.__doc__ is not None else "No Docstring yet!"
+    if help_section not in GLOBAL_HELP_DICTIONARY:
+        GLOBAL_HELP_DICTIONARY[help_section] = {}
+    GLOBAL_HELP_DICTIONARY[help_section][key] = doc.lstrip()
+    GLOBAL_IMPORT_DICTIONARY[key] = f
+    return key
+
+
+def add_to_func_list(f):
+    """
+    A function decorator that will add the function to the built-in list
+    """
+    _add_to_import_list(f, "functions")
+    return f
+
+
+def add_to_plan_list(f):
+    """
+    A function decorator that will add the plan to the built-in list
+    """
+    key = _add_to_import_list(f, "plans")
+    GLOBAL_PLAN_LIST.append(key)
+    return f
+
+
+def add_to_scan_list(f):
+    """
+    A function decorator that will add the plan to the built-in list
+    """
+    key = _add_to_import_list(f, "scans")
+    GLOBAL_SCAN_LIST.append(key)
+    return f
+
+
+def add_to_condition_list(f):
+    """
+    A function decorator that will add the condition to the built-in list
+    """
+    key = _add_to_import_list(f, "conditions")
+    GLOBAL_CONDITION_LIST.append(key)
+    return f
+
+
+def add_to_plan_time_dict(
+    f,
+    estimator="generic_estimate",
+    fixed=0,
+    overhead=0.5,
+    dwell="dwell",
+    points=None,
+    reset=0,
+    **kwargs,
+):
+    key = f.__name__
+    if key not in GLOBAL_PLAN_TIME_DICT:
+        GLOBAL_PLAN_TIME_DICT[key] = {}
+    GLOBAL_PLAN_TIME_DICT[key]["estimator"] = estimator
+    GLOBAL_PLAN_TIME_DICT[key]["fixed"] = fixed
+    GLOBAL_PLAN_TIME_DICT[key]["overhead"] = overhead
+    GLOBAL_PLAN_TIME_DICT[key]["dwell"] = dwell
+    GLOBAL_PLAN_TIME_DICT[key]["points"] = points
+    GLOBAL_PLAN_TIME_DICT[key]["reset"] = reset
+    GLOBAL_PLAN_TIME_DICT[key].update(kwargs)
+    return f
+
+
+@add_to_func_list
+def print_builtins(sections=None):
+    """Prints a list of built-in functions for ucal"""
+
+    if sections is None:
+        sections = sorted(GLOBAL_HELP_DICTIONARY.keys())
+    if type(sections) is str:
+        sections = [sections]
+    for key in sections:
+        textList = []
+        section = f"{key.capitalize()}"
+        if key == "xas":
+            for f in sorted(GLOBAL_HELP_DICTIONARY[key].keys()):
+                doc = GLOBAL_IMPORT_DICTIONARY[f]._short_doc
+                textList.append(f"{f}: {doc}")
+
+        else:
+            for f in sorted(GLOBAL_HELP_DICTIONARY[key].keys()):
+                doc = GLOBAL_HELP_DICTIONARY[key][f].split("\n")[0]
+                textList.append(f"{f}: {doc}")
+        boxed_text(section, textList, "white", width=100)
+
+
+@add_to_func_list
+def sst_help():
+    print(
+        "Welcome to SST. For a list of loaded functions and plans, call print_builtins() \n"
+        'To print the docstring for any of the built-in functions, use the built-in python "?"'
+        " command with the name of the desired function. \n I.e, typing activate_detector? will "
+        'print the help text for the "activate_detector" function'
+    )

nbs_bl/hw.py

@@ -0,0 +1,270 @@
+from .queueserver import GLOBAL_USER_STATUS
+from .printing import boxed_text
+from nbs_core.autoload import loadFromConfig as _loadFromConfig
+from nbs_core.autoload import instantiateOphyd, _find_deferred_devices, getMaxLoadPass
+
+
+def loadDevices(device_config, namespace=None, mode=None):
+    max_load_pass = getMaxLoadPass(device_config)
+
+    all_devices = {}
+    all_groups = {}
+    all_roles = {}
+    deferred_config = {}
+    deferred_devices = set()
+    for pass_num in range(1, max_load_pass + 1):
+        print(f"    Load pass {pass_num}/{max_load_pass}")
+
+        _, _, _deferred_config = _find_deferred_devices(device_config, mode=mode)
+
+        devices, groups, roles = loadFromConfig(
+            device_config,
+            instantiateOphyd,
+            alias=True,
+            namespace=namespace,
+            load_pass=pass_num,
+            mode=mode,
+        )
+
+
+        deferred_config.update(_deferred_config)
+        deferred_devices.update(_deferred_config.keys())
+
+        for device_name in devices:
+            deferred_config.pop(device_name, None)
+            deferred_devices.discard(device_name)
+        for group, group_devices in groups.items():
+            if group in all_groups:
+                all_groups[group] = all_groups[group] + group_devices
+            else:
+                all_groups[group] = group_devices
+        all_devices.update(devices)
+        all_roles.update(roles)
+    device_dict = {key: {"device": device, "loaded": True, "groups": [], "roles": [], "config": device_config.get(key, {})} for key, device in all_devices.items()}
+    for group, group_devices in all_groups.items():
+        for device in group_devices:
+            if device in device_dict:
+                device_dict[device]["groups"].append(group)
+            else:
+                device_dict[device] = {"device": None, "groups": [group], "loaded": False, "roles": [], "config": device_config.get(device, {})}
+    
+    for role, device in all_roles.items():
+        if device in device_dict:
+            device_dict[device]["roles"].append(role)
+        else:
+            device_dict[device] = {"device": None, "roles": [role], "loaded": False, "groups": [], "config": device_config.get(device, {})}
+    for device_name, dconf in deferred_config.items():
+        dinfo = {"loaded": False, "config": dconf}
+        device_dict[device_name] = dinfo
+
+    return device_dict
+
+def loadFromConfig(
+    config,
+    instantiateDevice,
+    alias=True,
+    namespace=None,
+    load_pass="auto",
+    filter_deferred=True,
+    mode=None,
+):
+    devices, groups, roles = _loadFromConfig(
+        config, instantiateDevice, alias, namespace, load_pass, filter_deferred, mode=mode
+    )
+    for key, device in devices.items():
+        globals()[key] = device
+    return devices, groups, roles
+
+
+class HardwareGroup:
+    def __init__(self, name="", use_redis=False):
+        self.groupname = name
+        self.devices = GLOBAL_USER_STATUS.request_status_dict(
+            f"{self.groupname.upper()}", use_redis=False
+        )
+        self.descriptions = GLOBAL_USER_STATUS.request_status_dict(
+            f"{self.groupname.upper()}_DESCRIPTIONS", use_redis=use_redis
+        )
+
+    def values(self):
+        return self.devices.values()
+
+    def items(self):
+        return self.devices.items()
+
+    def get_key(self, device_or_key):
+        if isinstance(device_or_key, str):
+            if device_or_key in self.devices:
+                return device_or_key
+            else:
+                raise KeyError(f"Device {device_or_key} not found")
+        else:
+            for k, v in self.devices.items():
+                if v == device_or_key:
+                    return k
+        raise KeyError(f"Device {device_or_key} not found")
+
+    def get(self, device_or_key):
+        key = self.get_key(device_or_key)
+        return self.devices[key]
+
+    def add(self, key, device, description="", **kwargs):
+        self.devices[key] = device
+        has_subdevices = False
+        if hasattr(device, "real_positioners"):
+            try:
+                for k2 in device.real_positioners._fields:
+                    self.descriptions[f"{key}.{k2}"] = getattr(
+                        device.real_positioners, k2
+                    ).name
+                    has_subdevices = True
+            except Exception as e:
+                print(f"Error getting real positioners for {key}: {e}")
+        if hasattr(device, "pseudo_positioners"):
+            try:
+                for k2 in device.pseudo_positioners._fields:
+                    self.descriptions[f"{key}.{k2}"] = getattr(
+                        device.pseudo_positioners, k2
+                    ).name
+                    has_subdevices = True
+            except Exception as e:
+                print(f"Error getting pseudo positioners for {key}: {e}")
+        if hasattr(device, "position_axes"):
+            try:
+                for k2 in device.position_axes:
+                    self.descriptions[f"{key}.{k2.attr_name}"] = k2.attr_name
+                    has_subdevices = True
+            except Exception as e:
+                print(f"Error getting position axes for {key}: {e}")
+        if not has_subdevices:
+            self.descriptions[key] = description
+
+    def remove(self, device_or_key):
+        key = self.get_key(device_or_key)
+        self.devices.pop(key, None)
+        self.descriptions.pop(key, None)
+        for dkey in list(self.descriptions.keys()):
+            if dkey.split(".")[0] == key:
+                self.descriptions.pop(dkey, None)
+
+    def describe(self, verbose=True, textFunction=None):
+        title = self.groupname
+        text = []
+        for key, device in self.devices.items():
+            name = device.name
+            if textFunction is None:
+                text.append(f"Key: {key}; Name: {name}")
+            else:
+                text.append(textFunction(self, key, device))
+            if verbose:
+                text.append(f"    {self.descriptions[key]}")
+        boxed_text(title, text, "white")
+
+
+class DetectorGroup(HardwareGroup):
+    def __init__(self, name="detectors", use_redis=False):
+        super().__init__(name=name, use_redis=use_redis)
+        self.status = GLOBAL_USER_STATUS.request_status_dict(
+            f"{self.groupname.upper()}_STATUS", use_redis=use_redis
+        )
+        self.thresholds = GLOBAL_USER_STATUS.request_status_dict(
+            f"{self.groupname.upper()}_THRESHOLDS", use_redis=use_redis
+        )
+        self.active = GLOBAL_USER_STATUS.request_status_list(
+            f"{self.groupname.upper()}_ACTIVE", use_redis=False
+        )
+        self.detector_sets = GLOBAL_USER_STATUS.request_status_dict(
+            f"{self.groupname.upper()}_SETS", use_redis=use_redis
+        )
+        self.roles = {}
+
+    def add(
+        self,
+        key,
+        device,
+        description="",
+        activate=True,
+        sets=None,
+        threshold=None,
+        **kwargs,
+    ):
+        super().add(key, device, description)
+        self.status[key] = "inactive"
+        if activate:
+            self.activate(key)
+        if sets is not None:
+            for set_name in sets:
+                self.add_to_set(device, set_name)
+        if threshold is not None:
+            self.thresholds[key] = threshold
+
+    def remove(self, device_or_key):
+        self.deactivate(device_or_key)
+        key = self.get_key(device_or_key)
+        super().remove(device_or_key)
+        self.status.pop(key, None)
+        self.thresholds.pop(key, None)
+
+    def activate(self, device_or_key, role=None):
+        key = self.get_key(device_or_key)
+        detector = self.devices[key]
+        if self.status[key] == "disabled":
+            print(f"Detector {key} is disabled and will not be activated")
+            return
+        else:
+            self.status[key] = "active"
+        if detector not in self.active:
+            self.active.append(detector)
+        if role is not None:
+            self.add_role(key, role)
+
+    def deactivate(self, device_or_key):
+        key = self.get_key(device_or_key)
+        device = self.get(device_or_key)
+        if device in self.active:
+            idx = self.active.index(device)
+            self.active.pop(idx)
+        if self.status[key] != "disabled":
+            self.status[key] = "inactive"
+
+    def activate_set(self, set_name):
+        for key in self.detector_sets.get(set_name, []):
+            self.activate(key)
+
+    def deactivate_set(self, set_name):
+        for key in self.detector_sets.get(set_name, []):
+            self.deactivate(key)
+
+    def add_set(self, set_name, set_keys):
+        self.detector_sets[set_name] = set_keys
+
+    def set_role(self, key, role):
+        self.roles[key] = role
+
+    def save_active_as_set(self, set_name):
+        set_keys = [self.get_key(device) for device in self.active]
+        self.add_set(set_name, set_keys)
+
+    def enable(self, device_or_key, activate=True):
+        key = self.get_key(device_or_key)
+        self.status[key] = "inactive"
+        if activate:
+            self.activate(device_or_key)
+
+    def disable(self, device_or_key):
+        key = self.get_key(device_or_key)
+        self.deactivate(device_or_key)
+        self.status[key] = "disabled"
+
+    def get_plot_hints(self):
+        plot_hints = {}
+        for detector in self.active:
+            key = self.get_key(detector)
+            role = self.roles.get(key, "auxiliary")
+            if role not in plot_hints:
+                plot_hints[role] = []
+            if hasattr(detector, "get_plot_hints"):
+                plot_hints[role] += detector.get_plot_hints()
+            else:
+                plot_hints[role].append(detector.name)
+        return plot_hints

nbs_bl/load.py

@@ -0,0 +1,113 @@
+from copy import deepcopy
+from importlib import import_module
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+
+def loadConfigDB(filename):
+    """
+    Load configuration from a TOML file.
+
+    Parameters
+    ----------
+    filename : str
+        The path to the TOML file containing the configuration.
+
+    Returns
+    -------
+    dict
+        The configuration loaded from the TOML file.
+    """
+    with open(filename, "rb") as f:
+        db = tomllib.load(f)
+    return db
+
+
+def simpleResolver(fullclassname):
+    """
+    Resolve a full class name to a class object.
+
+    Parameters
+    ----------
+    fullclassname : str
+        The full class name to resolve.
+
+    Returns
+    -------
+    type
+        The class object resolved from the full class name.
+    """
+    class_name = fullclassname.split(".")[-1]
+    module_name = ".".join(fullclassname.split(".")[:-1])
+    module = import_module(module_name)
+    cls = getattr(module, class_name)
+    return cls
+
+
+def instantiateDevice(device_key, info, cls=None, namespace=None):
+    """
+    Instantiate a device with given information.
+
+    Parameters
+    ----------
+    device_key : str
+        The key identifying the device.
+    info : dict
+        The information dictionary for the device.
+    cls : type, optional
+        The class to instantiate the device with. If not provided, it will be resolved from the info dictionary.
+    namespace : dict, optional
+        The namespace to add the instantiated device to.
+
+    Returns
+    -------
+    object
+        The instantiated device.
+    """
+    device_info = deepcopy(info)
+    if cls is not None:
+        device_info.pop("_target", None)
+    elif device_info.get("_target", None) is not None:
+        cls = simpleResolver(device_info.pop("_target"))
+    else:
+        raise KeyError("Could not find '_target' in {}".format(device_info))
+
+    popkeys = [key for key in device_info if key.startswith("_")]
+    for key in popkeys:
+        device_info.pop(key)
+
+    name = device_info.pop("name", device_key)
+    prefix = device_info.pop("prefix", "")
+    add_to_namespace = device_info.pop("_add_to_ns", True)
+    device = cls(prefix, name=name, **device_info)
+
+    if add_to_namespace and namespace is not None:
+        namespace[device_key] = device
+    return device
+
+
+def loadDeviceConfig(filename, namespace=None):
+    """
+    Load device configuration from a file and instantiate devices.
+
+    Parameters
+    ----------
+    filename : str
+        The path to the file containing the device configuration.
+    namespace : dict, optional
+        The namespace to add the instantiated devices to.
+
+    Returns
+    -------
+    dict
+        A dictionary of instantiated devices.
+    """
+    db = loadConfigDB(filename)
+    device_dict = {}
+    for key, info in db.items():
+        device = instantiateDevice(key, info, namespace=namespace)
+        device_dict[key] = device
+    return device_dict

nbs_bl/motors.py

@@ -0,0 +1,19 @@
+from ophyd.utils.errors import DisconnectedError
+from .beamline import GLOBAL_BEAMLINE
+from .help import add_to_func_list
+
+
+@add_to_func_list
+def list_motors(verbose=False):
+    """List the most important motors and their current positions"""
+
+    def textFunction(motors, key, device):
+        name = device.name
+        try:
+            position = device.position
+        except DisconnectedError:
+            position = "disconnected"
+        text = f"{name}: {position}"
+        return text
+
+    GLOBAL_BEAMLINE.motors.describe(verbose, textFunction)

nbs_bl/planStatus.py

@@ -0,0 +1,5 @@
+from .queueserver import GLOBAL_USER_STATUS
+
+GLOBAL_PLAN_STATUS = GLOBAL_USER_STATUS.request_status_dict(
+    "PLAN_STATUS", use_redis=True
+)

nbs_bl/plans/__init__.py

@@ -0,0 +1,8 @@
+from . import scans
+from . import xas
+from .flyscan_base import fly_scan
+from .plan_stubs import set_exposure
+from .metaplans import (
+    repeat_plan_sequence_for_duration,
+    repeat_plan_sequence_while_condition,
+)