# Set up the logbook. This configures bluesky's summaries of # data acquisition (scan type, ID, etc.). # Make ophyd listen to pyepics. from ophyd import setup_ophyd setup_ophyd() from metadatastore.mds import MDS # from metadataclient.mds import MDS from databroker import Broker from databroker.core import register_builtin_handlers from filestore.fs import FileStore # pull from /etc/metadatastore/connection.yaml or # /home/BLUSER/.config/metdatastore/connection.yml mds = MDS({'host': 'xf21id1-ca1', 'database': 'metadatastore', 'port': 27017, 'timezone': 'US/Eastern'}, auth=False) # mds = MDS({'host': CA, 'port': 7770}) # pull configuration from /etc/filestore/connection.yaml or # /home/BLUSER/.config/filestore/connection.yml db = Broker(mds, FileStore({'host': 'xf21id1-ca1', 'port': 27017, 'database': 'filestore'})) register_builtin_handlers(db.fs) # Subscribe metadatastore to documents. # If this is removed, data is not saved to metadatastore. from bluesky.global_state import gs gs.RE.subscribe('all', mds.insert)
import pytest # some module level globals. ophyd = None reason = '' try: import ophyd from ophyd import setup_ophyd except ImportError as ie: # pytestmark = pytest.mark.skip ophyd = None reason = str(ie) else: setup_ophyd() # define the classes only if ophyd is available # define a skip condition based on if ophyd is available or not requires_ophyd = pytest.mark.skipif(ophyd is None, reason=reason)
def setUpModule(): ophyd.setup_ophyd() logging.getLogger('ophyd.mixins').setLevel(logging.DEBUG)
def setup_module(module): ophyd.setup_ophyd()
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)
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 : string Name of databroker configuration. 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. # Set up a RunEngine and use metadata backed by a sqlite file. from bluesky import RunEngine from bluesky.utils import get_history 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 broker_name: # Set up a Broker. from databroker import Broker db = Broker.named(broker_name) ns['db'] = db 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. 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 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)
def setUpModule(): ophyd.setup_ophyd()