def get_qs_client(expname):
"""
Create a `happi.Client` from the experiment questionnaire.
Connects to the questionnaire webservice via the ``happi`` ``QSBackend``
using ``psdm_qs_cli`` to collect well-defined devices.
There are two possible methods of authentication to the
``QuestionnaireClient``, ``Kerberos`` and ``WS-Auth``. The first is simpler
but is not possible for all users, we therefore search for a configuration
file named ``web.cfg``, either hidden in the current directory or the users
home directory. This should contain the username and password needed to
authenticate into the ``QuestionnaireClient``. The format of this
configuration file is the standard ``.ini`` structure and should define the
username and password like:
.. code:: ini
[DEFAULT]
user = MY_USERNAME
pw = MY_PASSWORD
Parameters
----------
expname: ``str``
The experiment's name from the elog
Returns
-------
qs_client: `happi.Client`
Mapping from questionnaire ``python name`` to loaded object.
"""
# Determine which method of authentication we are going to use.
# Search for a configuration file, either in the current directory
# or hidden in the users home directory. If not found, attempt to
# launch the client via Kerberos
cfg = ConfigParser()
cfgs = cfg.read([
'qs.cfg', '.qs.cfg',
os.path.expanduser('~/.qs.cfg'), 'web.cfg', '.web.cfg',
os.path.expanduser('~/.web.cfg')
])
# Ws-auth
if cfgs:
user = cfg.get('DEFAULT', 'user', fallback=None)
try:
pw = cfg.get('DEFAULT', 'pw')
except NoOptionError as exc:
raise ValueError("Must specify password as 'pw' in "
"configuration file") from exc
qs_client = happi.Client(
database=QSBackend(expname, use_kerberos=False, user=user, pw=pw))
# Kerberos
else:
qs_client = happi.Client(
database=QSBackend(expname, use_kerberos=True))
return qs_client
def __init__(self, happi_json, system_json):
#Load happi client
self.client = happi.Client(database=JSONBackend(happi_json))
#Load system information
self.live_systems = simplejson.load(open(system_json, 'r'))
#Create cache of previously loaded devices
self.cache = {}
def add_device(obj, device):
# Needs metadata
if not hasattr(device, 'md'):
logger.error(
"Device %r has no stored metadata. "
"Unable to load in TyphonConsole", device)
return
# Create a temporary file
name = hashlib.md5(str(localtime()).encode('utf-8')).hexdigest()
name = os.path.join(tempfile.gettempdir(), name)
try:
# Dump the device in the tempfile
client = happi.Client(path=name, initialize=True)
client.add_device(device.md)
# Create a valid Python identifier
python_name = make_identifier(device.md.name)
# Create the script to load the device
load_script = (
f'import happi; '
f'from happi.loader import from_container; '
f'client = happi.Client(path="{name}"); '
f'md = client.find_device(name="{device.md.name}"); '
f'{python_name} = from_container(md)')
# Execute the script
obj.kernel.kernel_client.execute(load_script, silent=True)
except Exception:
logger.exception("Unable to add device %r to TyphonConsole.",
device.md.name)
# Cleanup after ourselves
if os.path.exists(name):
os.remove(name)
def test_add_then_load():
item = yaqc_bluesky.happi_containers.YAQItem(name="test", port=39424)
with tempfile.NamedTemporaryFile() as f:
backend = happi.backends.backend(f.name)
happi_client = happi.Client(database=backend)
happi_client.add_device(item)
output = happi_client.load_device(name="test")
def main():
#Parse command line
fclass = argparse.RawDescriptionHelpFormatter
parser = argparse.ArgumentParser(epilog=description,
formatter_class=fclass)
#Arguments
parser.add_argument('name', help='Name of Device')
parser.add_argument('-e',
'--embedded',
dest='embedded',
help='Choice to use embedded screen',
default=False,
action='store_true')
parser.add_argument('-b',
'--block',
dest='block',
help='Block the main thread while '
'the screen is open',
default=False,
action='store_true')
parser.add_argument('-d',
'--dir',
dest='dir',
help='Directory to launch screen from',
default=None)
#Parse arguments
args = parser.parse_args()
client = happi.Client()
try:
device = client.load_device(name=args.name)
except happi.errors.SearchError:
print('Unable to locate any device with '
'name {} in the database.'
''.format(args.name))
return
#Create string of macros based on template
env = Environment().from_string(device.macros)
macros = env.render(**device.post())
#Gather screen path
if args.embedded:
screen = device.embedded_screen
else:
screen = device.main_screen
#Launch screen
launch(screen, wait=args.block, wd=args.dir, macros=macros)
def get_happi_objs(db, hutch):
"""
Get the relevant devices for ``hutch`` from ``db``.
This depends on a JSON ``happi`` database stored somewhere in the file
system and handles setting up the ``happi.Client`` and querying the data
base for devices.
Parameters
----------
db: ``str``
Path to database
hutch: ``str``
Name of hutch
Returns
-------
objs: ``dict``
A mapping from device name to device
"""
# Load the happi Client
client = happi.Client(path=db)
containers = list()
# Find upstream devices based on lightpath configuration
beamline_conf = beamlines.get(hutch.upper())
# Something strange is happening if there are no upstream devices
if not beamline_conf:
logger.warning("Unable to find lightpath for %s", hutch.upper())
beamline_conf = {}
# Add the complete hutch beamline
beamline_conf[hutch.upper()] = {}
# Base beamline
for beamline, conf in beamline_conf.items():
# Assume we want hutch devices that are active and in the bounds
# determined by the beamline configuration
reqs = dict(beamline=beamline,
active=True,
start=conf.get('start', 0),
end=conf.get('end', None))
results = client.search_range(key='z', **reqs)
blc = [res.device for res in results]
# Add the beamline containers to the complete list
if blc:
containers.extend(blc)
else:
logger.warning("No devices found in database for %s",
beamline.upper())
# Instantiate the devices needed
dev_namespace = load_devices(*containers, pprint=False)
return dev_namespace.__dict__
def lcls_client():
# Reset the configuration database
lightpath.controller.beamlines = {
'MEC': {
'HXR': {}
},
'CXI': {
'HXR': {}
},
'XCS': {
'HXR': {}
}
}
db = os.path.join(os.path.dirname(__file__), 'path.json')
return happi.Client(path=db)
def get_lightpath(db, hutch):
"""
Create a lightpath from relevant ``happi`` objects.
Parameters
----------
db: ``str``
Path to database
hutch: ``str``
Name of hutch
Returns
-------
path: ``lightpath.BeamPath``
Object that provides a convenient way to visualize all the devices
that may block the beam on the way to the interaction point.
"""
# Load the happi Client
client = happi.Client(path=db)
# Allow the lightpath module to create a path
lc = lightpath.LightController(client, endstations=[hutch.upper()])
# Return the BeamPath object created by the LightController
return lc.beamlines[hutch.upper()]
super(HappiDeviceExplorer, self).__init__(parent=parent)
self.filter_label = QtWidgets.QLabel("&Filter")
self.filter_edit = QtWidgets.QLineEdit()
self.filter_label.setBuddy(self.filter_edit)
def set_filter(text):
self.view.proxy_model.setFilterRegExp(text)
self.filter_edit.textEdited.connect(set_filter)
self.view = happi.qt.model.HappiDeviceListView(self)
self.setLayout(QtWidgets.QGridLayout())
self.layout().addWidget(self.filter_label, 1, 0)
self.layout().addWidget(self.filter_edit, 1, 1)
self.layout().addWidget(self.view, 3, 0, 1, 2)
if __name__ == "__main__":
app = QtWidgets.QApplication([])
file_path = pathlib.Path(__file__).resolve()
db_path = file_path.parent.parent / "db.json"
cli = happi.Client(path=db_path)
w = HappiDeviceExplorer()
w.view.client = cli
w.view.search(beamline="DEMO_BEAMLINE")
w.show()
app.exec_()
from bluesky.callbacks.best_effort import BestEffortCallback
from bluesky.callbacks.zmq import Publisher as zmqPublisher
from bluesky_kafka import Publisher as kafkaPublisher
from bluesky_adaptive.per_start import adaptive_plan
from bluesky_queueserver.plan import configure_plan
import databroker
import happi
import happi.loader
ip = IPython.get_ipython()
hclient = happi.Client(path='/usr/local/share/happi/test_db.json')
db = databroker.catalog['MAD']
RE = RunEngine()
bec = BestEffortCallback()
zmq_publisher = zmqPublisher("127.0.0.1:4567")
kafka_publisher = kafkaPublisher(
topic="mad.bluesky.documents",
bootstrap_servers="127.0.0.1:9092",
key="kafka-unit-test-key",
# work with a single broker
producer_config={
"acks": 1,
"enable.idempotence": False,
"request.timeout.ms": 5000,
def trigger(self):
super().trigger()
uid = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S.%f")
sim = Simulate(self._sirepo_sim_address)
data = sim.auth('srw', self._sim_id)
# all simulated componets
# sim_fee_m1h = sim.find_element(data['models']['beamline'], 'title', 'fee_m1h')
# sim_fee_m2h = sim.find_element(data['models']['beamline'], 'title', 'fee_m2h')
# sim_hx2_slits = sim.find_element(data['models']['beamline'], 'title', 'hx2_slits')
sim_um6_slits = sim.find_element(data['models']['beamline'], 'title',
'um6_slits')
# sim_xrt_m1h = sim.find_element(data['models']['beamline'], 'title', 'xrt_m1h')
# sim_xrt_m2h = sim.find_element(data['models']['beamline'], 'title', 'xrt_m2h')
# sim_hdx_dg2_slits = sim.find_element(data['models']['beamline'], 'title', 'hxd_dg2_slits')
# reading current value of motors
x = self._x_motor.read()[self._x_field]['value']
y = self._y_motor.read()[self._y_field]['value']
# set value of motor to change x and y position of slit at each scan
sim_um6_slits['horizontalOffset'] = x
sim_um6_slits['verticalOffset'] = y
# setting values of devices in beamline according to current beamline value
client = happi.Client(path='./happi_db.json')
# all devices from happi database
# fee_m1h = client.find_device(name = 'fee_m1h')
# fee_m2h = client.find_device(name = 'fee_m2h')
# hx2_slits = client.find_device(name = 'hx2_slits')
um6_slits = client.find_device(name="um6_slits")
# xrt_m1h = client.find_device(name = 'xrt_m1h')
# xrt_m2h = client.find_device(name = 'xrt_m2h')
# hxd_dg2_slits = client.find_device(name = 'hxd_dg2_slits')
# getting value from these devices and set to simulated ones
# sim_fee_m1h['position'] = fee_m1h.z
# sim_fee_m2h['position'] = fee_m2h.z
# sim_hx2_slits['position'] = hx2_slits.z
sim_um6_slits['position'] = um6_slits.z
# sim_xrt_m1h['position'] = xrt_m1h.z
# sim_xrt_m2h['position'] = xrt_m2h.z
# sim_hdx_dg2_slits['position'] = hxd_dg2_slits.z
watch = sim.find_element(data['models']['beamline'], 'title',
'Watchpoint')
data['report'] = 'watchpointReport{}'.format(watch['id'])
sim.run_simulation()
data_file_path = os.path.abspath('.') + '/data/%s.txt' % uid
dec = sim.get_datafile().decode('UTF-8')
datafile = open(data_file_path, "w+")
datafile.write(dec)
datafile.close()
data_dict = extract_simulation_data(data_file_path)
self.maxim.put(np.amax(data_dict['data']))
hf5 = h5py.File(self._image_file, 'a')
hf5.create_dataset(uid, data=data_dict['data'])
if 'x_range' in hf5 or 'y_range' in hf5:
pass
else:
hf5['x_range'] = data_dict['x_range']
hf5['y_range'] = data_dict['y_range']
hf5.close()
return NullStatus()
import happi client = happi.Client(path=r"C:\Users\gaire01\Downloads\codes\happi_db.json") x1 = client.find_device(name='xrt_m1h') print(x1.z)
