def macro_sweep_test(target): logging.info( 'macro_sweep_test initiated with target {:0.4f}'.format(target)) RE = RunEngine({}) bec = BestEffortCallback() RE.subscribe(bec) RE.waiting_hook = ProgressBarManager() RE(run_wrapper(rel_smooth_sweep_test(tst_23, target)))
def pbar_manager_for_notebook(delay_draw: float = 0.2) -> ProgressBarManager: """ Helper method for generating managers when using notebooks. Returns ------- ProgressBarManager A manager that creates progress bars for Jupuyter notebooks """ return ProgressBarManager( partial(NotebookProgressBar, delay_draw=delay_draw))
def macro_RSXS_smooth_sweep(stroke_height, stroke_spacing, n_strokes, both_directions=True): """ macro_RSXS_smooth_sweep This method wraps up the bluesky/ophyd codeand allows users to drive the LU20 experiment with minimal code overhead. It contains the following bluesky plan. This bluesky plan moves a 2-axis actuator across multiple traversals of a sample. The plan traverses the entirety of the stroke_height (y-axis) and after each traversal, steps in the x-axis by the stroke_spacing.It may be configured to scan in only a single direction and shutter the beam for the opposite direction. This removes the shutter at the beginning of the plan and reinserts it at the end. At the end of the plan, the sample is moved to its original y-axis position but with an x-axis posiiton ready for the next run. For more details about the path, see the documentation of the xy_sequencer, the method that generates the sample's path. Parameters ---------- stroke_height : float Vertical distance (y-axs) of each stroke. stroke_spacing : float Horizontal distance between individual strokes. n_strokes : int Number of strokes to complete. both_directions : bool, optional Defaults to True. If this value is true the beam will be scanned across the sample while moving in both vertical directions. If false, the beam is only scanned in a single direction. """ RE = RunEngine({}) bec = BestEffortCallback() RE.subscribe(bec) RE.waiting_hook = ProgressBarManager() RE( run_wrapper( rel_smooth_sweep(mot_x=rsxs_sample_x, mot_y=rsxs_sample_y, shutter=shutter, stroke_height=stroke_height, stroke_spacing=stroke_spacing, n_strokes=n_strokes, both_directions=both_directions)))
def test_mv_progress(RE, hw): motor1 = hw.motor1 motor2 = hw.motor2 RE.waiting_hook = ProgressBarManager() # moving time > delay_draw motor1.delay = 0.5 motor1.delay = 0.5 RE(mv(motor1, 0, motor2, 0)) # moving time < delay_draw motor1.delay = 0.01 motor1.delay = 0.01 RE(mv(motor1, 0, motor2, 0))
def test_mv_progress(fresh_RE): RE = fresh_RE RE.waiting_hook = ProgressBarManager() motor1 = Mover('motor1', OrderedDict([('motor1', lambda x: x), ('motor1_setpoint', lambda x: x)]), {'x': 0}) motor2 = Mover('motor2', OrderedDict([('motor2', lambda x: x), ('motor2_setpoint', lambda x: x)]), {'x': 0}) assert RE.waiting_hook.delay_draw == 0.2 # moving time > delay_draw motor1._fake_sleep = 0.5 motor1._fake_sleep = 0.5 RE(mv(motor1, 0, motor2, 0)) # moving time < delay_draw motor1._fake_sleep = 0.01 motor1._fake_sleep = 0.01 RE(mv(motor1, 0, motor2, 0))
# keep track of callback subscriptions callback_db = {} # set up databroker import databroker db = databroker.Broker.named('mongoCat') callback_db['Broker'] = RE.subscribe(db.insert) # Set up SupplementalData. from bluesky import SupplementalData sd = SupplementalData() RE.preprocessors.append(sd) # Add a progress bar. from bluesky.utils import ProgressBarManager pbar_manager = ProgressBarManager() RE.waiting_hook = pbar_manager # Register bluesky IPython magics. from IPython import get_ipython from bluesky.magics import BlueskyMagics get_ipython().register_magics(BlueskyMagics) get_ipython().magic("automagic 0") # Turn off automagic # Set up the BestEffortCallback. from bluesky.callbacks.best_effort import BestEffortCallback bec = BestEffortCallback() callback_db['BestEffortCallback'] = RE.subscribe(bec) peaks = bec.peaks # just as alias for less typing bec.disable_baseline()
def macro_VT50_smooth_sweep(short_edge_end, long_edge_end, n_strokes, scalar=1.0, min_base=.05, min_v=.07, both_directions=True): """ macro_RSXS_smooth_sweep This method wraps up the bluesky/ophyd codeand allows users to drive the LT00 experiment with minimal code overhead. It contains the following bluesky plan. This bluesky plan moves a 3-axis actuator across multiple traversals of a sample. The plan traverses the space enclosed in a plane defined by the motors' starting location and the two positions short_edge_end and long_edge_end. Parameters ---------- short_edge_end : tuple or np.array 3-length (x,y,z) iteralbe specifying the end location of the short steps. long_edge_end : tuple or np.array 3-length (x,y,z) iteralbe specifying the end location of the long sweep. n_strokes : int Number of strokes to complete. scalar : float Scale the motor velocities by this factor. Defaults to 1.0. min_base : float Set motor's Base velocity. Larger numbers means the motor accelerates and decelerates more quickly. This value must be less than min_v. Values larger than 2 are not recommended. min_v : float Set the motor's minimum velocity. Must be larger than min_base. Larger numbers means the motor accelerates and decelerates more quickly. Values larger than 2 are not recommended. """ RE = RunEngine({}) bec = BestEffortCallback() RE.subscribe(bec) RE.waiting_hook = ProgressBarManager() RE( run_wrapper( rel_smooth_sweep(mot_x=sample_x, mot_y=sample_y, mot_z=sample_z, shutter=shutter, short_edge_end=short_edge_end, long_edge_end=long_edge_end, n_strokes=n_strokes, scalar=scalar, min_base=min_base, min_v=min_v)))
get_ipython().magic("matplotlib qt") # Create a databroker backed by temporary files db = Broker.named("mycat") def spy(name, doc): pass # Insert all metadata/data captured into db. RE.subscribe(db.insert) RE.subscribe(spy) # Make a progress bar RE.waiting_hook = ProgressBarManager() # Running in simulation mode? SIM_MODE = True with SignalCollector(), NamedDevices(), TmpFilenameScheme(): # All Signals with a sim:// prefix or without a prefix will come from this provider if SIM_MODE: sim = SignalCollector.add_provider(sim=SimProvider(), set_default=True) else: # Do something like this here # ca = SignalCollector.add_provider(ca=CAProvider(), set_default=True) pass # A PMAC has a trajectory scan interface and 16 Co-ordinate systems # which may have motors in them pmac1 = pmac.PMAC("BLxxI-MO-PMAC-01:")
def configure_base(user_ns, broker_name, *, bec=True, epics_context=True, magics=True, mpl=True, ophyd_logging=True, pbar=True): """ Perform base setup and instantiation of important objects. This factory function instantiates the following and adds them to the namespace: * ``RE`` -- a RunEngine * ``db`` -- a Broker (from "databroker"), subscribe to ``RE`` * ``bec`` -- a BestEffortCallback, subscribed to ``RE`` * ``peaks`` -- an alias for ``bec.peaks`` * ``sd`` -- a SupplementalData preprocessor, added to ``RE.preprocessors`` * ``pbar_maanger`` -- a ProgressBarManager, set as the ``RE.waiting_hook`` And it performs some low-level configuration: * creates a context in ophyd's control layer (``ophyd.setup_ophyd()``) * turns out interactive plotting (``matplotlib.pyplot.ion()``) * bridges the RunEngine and Qt event loops (``bluesky.utils.install_kicker()``) * logs ERROR-level log message from ophyd to the standard out Parameters ---------- user_ns: dict a namespace --- for example, ``get_ipython().user_ns`` broker_name : Union[str, Broker] Name of databroker configuration or a Broker instance. bec : boolean, optional True by default. Set False to skip BestEffortCallback. epics_context : boolean, optional True by default. Set False to skip ``setup_ophyd()``. magics : boolean, optional True by default. Set False to skip registration of custom IPython magics. mpl : boolean, optional True by default. Set False to skip matplotlib ``ion()`` at event-loop bridging. ophyd_logging : boolean, optional True by default. Set False to skip ERROR-level log configuration for ophyd. pbar : boolean, optional True by default. Set false to skip ProgressBarManager. Returns ------- names : list list of names added to the namespace Examples -------- Configure IPython for CHX. >>>> configure_base(get_ipython().user_ns, 'chx'); """ ns = {} # We will update user_ns with this at the end. # Test if we are in Jupyter or IPython: in_jupyter = user_ns['get_ipython']().has_trait('kernel') # Set up a RunEngine and use metadata backed by a sqlite file. from bluesky import RunEngine from bluesky.utils import get_history # if RunEngine already defined grab it # useful when users make their own custom RunEngine if 'RE' in user_ns: RE = user_ns['RE'] else: RE = RunEngine(get_history()) ns['RE'] = RE # Set up SupplementalData. # (This is a no-op until devices are added to it, # so there is no need to provide a 'skip_sd' switch.) from bluesky import SupplementalData sd = SupplementalData() RE.preprocessors.append(sd) ns['sd'] = sd if isinstance(broker_name, str): # Set up a Broker. from databroker import Broker db = Broker.named(broker_name) ns['db'] = db else: db = broker_name RE.subscribe(db.insert) if pbar and not in_jupyter: # Add a progress bar. from bluesky.utils import ProgressBarManager pbar_manager = ProgressBarManager() RE.waiting_hook = pbar_manager ns['pbar_manager'] = pbar_manager if magics: # Register bluesky IPython magics. from bluesky.magics import BlueskyMagics get_ipython().register_magics(BlueskyMagics) if bec: # Set up the BestEffortCallback. from bluesky.callbacks.best_effort import BestEffortCallback _bec = BestEffortCallback() bec = _bec RE.subscribe(_bec) if in_jupyter: _bec.disable_plots() ns['bec'] = _bec ns['peaks'] = _bec.peaks # just as alias for less typing if mpl: # Import matplotlib and put it in interactive mode. import matplotlib.pyplot as plt ns['plt'] = plt plt.ion() # Commented to allow more intelligent setting of kickers (for Jupyter and IPython): ## Make plots update live while scans run. # from bluesky.utils import install_kicker # install_kicker() # Make plots update live while scans run. if in_jupyter: from bluesky.utils import install_nb_kicker install_nb_kicker() else: from bluesky.utils import install_qt_kicker install_qt_kicker() if not ophyd_logging: # Turn on error-level logging, particularly useful for knowing when # pyepics callbacks fail. import logging import ophyd.ophydobj ch = logging.StreamHandler() ch.setLevel(logging.ERROR) ophyd.ophydobj.logger.addHandler(ch) # convenience imports # some of the * imports are for 'back-compatibility' of a sort -- we have # taught BL staff to expect LiveTable and LivePlot etc. to be in their # namespace import numpy as np ns['np'] = np import bluesky.callbacks ns['bc'] = bluesky.callbacks import_star(bluesky.callbacks, ns) import bluesky.plans ns['bp'] = bluesky.plans import_star(bluesky.plans, ns) import bluesky.plan_stubs ns['bps'] = bluesky.plan_stubs import_star(bluesky.plan_stubs, ns) # special-case the commonly-used mv / mvr and its aliases mov / movr4 ns['mv'] = bluesky.plan_stubs.mv ns['mvr'] = bluesky.plan_stubs.mvr ns['mov'] = bluesky.plan_stubs.mov ns['movr'] = bluesky.plan_stubs.movr import bluesky.preprocessors ns['bpp'] = bluesky.preprocessors import bluesky.callbacks.broker import_star(bluesky.callbacks.broker, ns) import bluesky.simulators import_star(bluesky.simulators, ns) user_ns.update(ns) return list(ns)
class BlueskyMagics(Magics, metaclass=MetaclassForClassProperties): """ IPython magics for bluesky. To install: >>> ip = get_ipython() >>> ip.register_magics(BlueskyMagics) Optionally configure default detectors and positioners by setting the class attributes: * ``BlueskyMagics.detectors`` * ``BlueskyMagics.positioners`` For more advanced configuration, access the magic's RunEngine instance and ProgressBarManager instance: * ``BlueskyMagics.RE`` * ``BlueskyMagics.pbar_manager`` """ RE = RunEngine({}, loop=asyncio.new_event_loop()) pbar_manager = ProgressBarManager() def _ensure_idle(self): if self.RE.state != 'idle': print('The RunEngine invoked by magics cannot be resumed.') print('Aborting...') self.RE.abort() @line_magic def mov(self, line): if len(line.split()) % 2 != 0: raise TypeError("Wrong parameters. Expected: " "%mov motor position (or several pairs like that)") args = [] for motor, pos in partition(2, line.split()): args.append(eval(motor, self.shell.user_ns)) args.append(eval(pos, self.shell.user_ns)) plan = bps.mv(*args) self.RE.waiting_hook = self.pbar_manager try: self.RE(plan) except RunEngineInterrupted: ... self.RE.waiting_hook = None self._ensure_idle() return None @line_magic def movr(self, line): if len(line.split()) % 2 != 0: raise TypeError("Wrong parameters. Expected: " "%mov motor position (or several pairs like that)") args = [] for motor, pos in partition(2, line.split()): args.append(eval(motor, self.shell.user_ns)) args.append(eval(pos, self.shell.user_ns)) plan = bps.mvr(*args) self.RE.waiting_hook = self.pbar_manager try: self.RE(plan) except RunEngineInterrupted: ... self.RE.waiting_hook = None self._ensure_idle() return None @line_magic def ct(self, line): # If the deprecated BlueskyMagics.detectors list is non-empty, it has # been configured by the user, and we must revert to the old behavior. if type(self).detectors: if line.strip(): dets = eval(line, self.shell.user_ns) else: dets = type(self).detectors else: # new behaviour devices_dict = get_labeled_devices(user_ns=self.shell.user_ns) if line.strip(): if '[' in line or ']' in line: raise ValueError("It looks like you entered a list like " "`%ct [motors, detectors]` " "Magics work a bit differently than " "normal Python. Enter " "*space-separated* labels like " "`%ct motors detectors`.") # User has provided a white list of labels like # %ct label1 label2 labels = line.strip().split() else: labels = ['detectors'] dets = [] for label in labels: dets.extend(obj for _, obj in devices_dict.get(label, [])) plan = bp.count(dets) print("[This data will not be saved. " "Use the RunEngine to collect data.]") try: self.RE(plan, _ct_callback) except RunEngineInterrupted: ... self._ensure_idle() return None FMT_PREC = 6 @line_magic def wa(self, line): "List positioner info. 'wa' stands for 'where all'." # If the deprecated BlueskyMagics.positioners list is non-empty, it has # been configured by the user, and we must revert to the old behavior. if type(self).positioners: if line.strip(): positioners = eval(line, self.shell.user_ns) else: positioners = type(self).positioners if len(positioners) > 0: _print_positioners(positioners, precision=self.FMT_PREC) else: # new behaviour devices_dict = get_labeled_devices(user_ns=self.shell.user_ns) if line.strip(): if '[' in line or ']' in line: raise ValueError("It looks like you entered a list like " "`%wa [motors, detectors]` " "Magics work a bit differently than " "normal Python. Enter " "*space-separated* labels like " "`%wa motors detectors`.") # User has provided a white list of labels like # %wa label1 label2 labels = line.strip().split() else: # Show all labels. labels = list(devices_dict.keys()) for label in labels: print(label) try: devices = devices_dict[label] all_children = [(k, getattr(obj, k)) for _, obj in devices for k in getattr(obj, 'read_attrs', [])] except KeyError: print('<no matches for this label>') continue # Search devices and all their children for positioners. positioners = [ dev for _, dev in devices + all_children if is_positioner(dev) ] if positioners: _print_positioners(positioners, precision=self.FMT_PREC, prefix=" " * 2) print() # blank line # Just display the top-level devices in the namespace (no # children). _print_devices(devices, prefix=" " * 2) print() # blank line
class BlueskyMagics(Magics): """ IPython magics for bluesky. To install: >>> ip = get_ipython() >>> ip.register_magics(BlueskyMagics) Optionally configure default detectors and positioners by setting the class attributes: * ``BlueskyMagics.detectors`` * ``BlueskyMagics.positioners`` For more advanced configuration, access the magic's RunEngine instance and ProgressBarManager instance: * ``BlueskyMagics.RE`` * ``BlueskyMagics.pbar_manager`` """ RE = RunEngine({}, loop=asyncio.new_event_loop()) pbar_manager = ProgressBarManager() def _ensure_idle(self): if self.RE.state != 'idle': print('The RunEngine invoked by magics cannot be resumed.') print('Aborting...') self.RE.abort() @line_magic def mov(self, line): if len(line.split()) % 2 != 0: raise TypeError("Wrong parameters. Expected: " "%mov motor position (or several pairs like that)") args = [] for motor, pos in partition(2, line.split()): args.append(eval(motor, self.shell.user_ns)) args.append(eval(pos, self.shell.user_ns)) plan = bps.mv(*args) self.RE.waiting_hook = self.pbar_manager try: self.RE(plan) except RunEngineInterrupted: ... self.RE.waiting_hook = None self._ensure_idle() return None @line_magic def movr(self, line): if len(line.split()) % 2 != 0: raise TypeError("Wrong parameters. Expected: " "%mov motor position (or several pairs like that)") args = [] for motor, pos in partition(2, line.split()): args.append(eval(motor, self.shell.user_ns)) args.append(eval(pos, self.shell.user_ns)) plan = bps.mvr(*args) self.RE.waiting_hook = self.pbar_manager try: self.RE(plan) except RunEngineInterrupted: ... self.RE.waiting_hook = None self._ensure_idle() return None detectors = [] @line_magic def ct(self, line): if line.strip(): dets = eval(line, self.shell.user_ns) else: dets = self.detectors plan = bp.count(dets) print("[This data will not be saved. " "Use the RunEngine to collect data.]") try: self.RE(plan, _ct_callback) except RunEngineInterrupted: ... self._ensure_idle() return None positioners = [] FMT_PREC = 6 @line_magic def wa(self, line): "List positioner info. 'wa' stands for 'where all'." if line.strip(): positioners = eval(line, self.shell.user_ns) else: positioners = self.positioners positioners = sorted(set(positioners), key=attrgetter('name')) values = [] for p in positioners: try: values.append(p.position) except Exception as exc: values.append(exc) headers = ['Positioner', 'Value', 'Low Limit', 'High Limit', 'Offset'] LINE_FMT = '{: <30} {: <11} {: <11} {: <11} {: <11}' lines = [] lines.append(LINE_FMT.format(*headers)) for p, v in zip(positioners, values): if not isinstance(v, Exception): try: prec = p.precision except Exception: prec = self.FMT_PREC value = np.round(v, decimals=prec) try: low_limit, high_limit = p.limits except Exception as exc: low_limit = high_limit = exc.__class__.__name__ else: low_limit = np.round(low_limit, decimals=prec) high_limit = np.round(high_limit, decimals=prec) try: offset = p.user_offset.get() except Exception as exc: offset = exc.__class__.__name__ else: offset = np.round(offset, decimals=prec) else: value = v.__class__.__name__ # e.g. 'DisconnectedError' low_limit = high_limit = offset = '' lines.append(LINE_FMT.format(p.name, value, low_limit, high_limit, offset)) print('\n'.join(lines))
def configure_base( user_ns, broker_name, *, bec=True, epics_context=False, magics=True, mpl=True, configure_logging=True, pbar=True, ipython_exc_logging=True, ): """ Perform base setup and instantiation of important objects. This factory function instantiates essential objects to data collection environments at NSLS-II and adds them to the current namespace. In some cases (documented below), it will check whether certain variables already exist in the user name space, and will avoid creating them if so. The following are added: * ``RE`` -- a RunEngine This is created only if an ``RE`` instance does not currently exist in the namespace. * ``db`` -- a Broker (from "databroker"), subscribe to ``RE`` * ``bec`` -- a BestEffortCallback, subscribed to ``RE`` * ``peaks`` -- an alias for ``bec.peaks`` * ``sd`` -- a SupplementalData preprocessor, added to ``RE.preprocessors`` * ``pbar_maanger`` -- a ProgressBarManager, set as the ``RE.waiting_hook`` And it performs some low-level configuration: * creates a context in ophyd's control layer (``ophyd.setup_ophyd()``) * turns on interactive plotting (``matplotlib.pyplot.ion()``) * bridges the RunEngine and Qt event loops (``bluesky.utils.install_kicker()``) * logs ERROR-level log message from ophyd to the standard out Parameters ---------- user_ns: dict a namespace --- for example, ``get_ipython().user_ns`` broker_name : Union[str, Broker] Name of databroker configuration or a Broker instance. bec : boolean, optional True by default. Set False to skip BestEffortCallback. epics_context : boolean, optional True by default. Set False to skip ``setup_ophyd()``. magics : boolean, optional True by default. Set False to skip registration of custom IPython magics. mpl : boolean, optional True by default. Set False to skip matplotlib ``ion()`` at event-loop bridging. configure_logging : boolean, optional True by default. Set False to skip INFO-level logging to /var/logs/bluesky/bluesky.log. pbar : boolean, optional True by default. Set false to skip ProgressBarManager. ipython_exc_logging : boolean, optional True by default. Exception stack traces will be written to IPython log file when IPython logging is enabled. Returns ------- names : list list of names added to the namespace Examples -------- Configure IPython for CHX. >>>> configure_base(get_ipython().user_ns, 'chx'); """ ns = {} # We will update user_ns with this at the end. # Protect against double-subscription. SENTINEL = "__nslsii_configure_base_has_been_run" if user_ns.get(SENTINEL): raise RuntimeError( "configure_base should only be called once per process.") ns[SENTINEL] = True # Set up a RunEngine and use metadata backed by files on disk. from bluesky import RunEngine, __version__ as bluesky_version if LooseVersion(bluesky_version) >= LooseVersion("1.6.0"): # current approach using PersistentDict from bluesky.utils import PersistentDict directory = os.path.expanduser("~/.config/bluesky/md") os.makedirs(directory, exist_ok=True) md = PersistentDict(directory) else: # legacy approach using HistoryDict from bluesky.utils import get_history md = get_history() # if RunEngine already defined grab it # useful when users make their own custom RunEngine if "RE" in user_ns: RE = user_ns["RE"] else: RE = RunEngine(md) ns["RE"] = RE # Set up SupplementalData. # (This is a no-op until devices are added to it, # so there is no need to provide a 'skip_sd' switch.) from bluesky import SupplementalData sd = SupplementalData() RE.preprocessors.append(sd) ns["sd"] = sd if isinstance(broker_name, str): # Set up a Broker. from databroker import Broker db = Broker.named(broker_name) ns["db"] = db else: db = broker_name RE.subscribe(db.insert) if pbar: # Add a progress bar. from bluesky.utils import ProgressBarManager pbar_manager = ProgressBarManager() RE.waiting_hook = pbar_manager ns["pbar_manager"] = pbar_manager if magics: # Register bluesky IPython magics. from bluesky.magics import BlueskyMagics get_ipython().register_magics(BlueskyMagics) if bec: # Set up the BestEffortCallback. from bluesky.callbacks.best_effort import BestEffortCallback _bec = BestEffortCallback() RE.subscribe(_bec) ns["bec"] = _bec ns["peaks"] = _bec.peaks # just as alias for less typing if mpl: # Import matplotlib and put it in interactive mode. import matplotlib.pyplot as plt ns["plt"] = plt plt.ion() # Make plots update live while scans run. if LooseVersion(bluesky_version) < LooseVersion("1.6.0"): from bluesky.utils import install_kicker install_kicker() if epics_context: # Create a context in the underlying EPICS client. from ophyd import setup_ophyd setup_ophyd() if configure_logging: configure_bluesky_logging(ipython=get_ipython()) if ipython_exc_logging: # IPython logging must be enabled separately from nslsii.common.ipynb.logutils import log_exception configure_ipython_exc_logging(exception_logger=log_exception, ipython=get_ipython()) # always configure %xmode minimal get_ipython().magic("xmode minimal") # convenience imports # some of the * imports are for 'back-compatibility' of a sort -- we have # taught BL staff to expect LiveTable and LivePlot etc. to be in their # namespace import numpy as np ns["np"] = np import bluesky.callbacks ns["bc"] = bluesky.callbacks import_star(bluesky.callbacks, ns) import bluesky.plans ns["bp"] = bluesky.plans import_star(bluesky.plans, ns) import bluesky.plan_stubs ns["bps"] = bluesky.plan_stubs import_star(bluesky.plan_stubs, ns) # special-case the commonly-used mv / mvr and its aliases mov / movr4 ns["mv"] = bluesky.plan_stubs.mv ns["mvr"] = bluesky.plan_stubs.mvr ns["mov"] = bluesky.plan_stubs.mov ns["movr"] = bluesky.plan_stubs.movr import bluesky.preprocessors ns["bpp"] = bluesky.preprocessors import bluesky.callbacks.broker import_star(bluesky.callbacks.broker, ns) import bluesky.simulators import_star(bluesky.simulators, ns) user_ns.update(ns) return list(ns)