def _pyscript_runner_default(self):
if self.mode == 'client':
# em = self.extraction_line_manager
ip = InitializationParser()
elm = ip.get_plugin('Experiment', category='general')
runner = elm.find('runner')
host, port, kind = None, None, None
if runner is not None:
comms = runner.find('communications')
host = comms.find('host')
port = comms.find('port')
kind = comms.find('kind')
if host is not None:
host = host.text # if host else 'localhost'
if port is not None:
port = int(port.text) # if port else 1061
kind = kind.text # if kind else 'udp'
runner = RemotePyScriptRunner(host, port, kind)
else:
runner = PyScriptRunner()
return runner
def _monitor_factory(self):
mon = None
isok = True
self.debug('Experiment Executor mode={}'.format(self.mode))
if self.mode == 'client':
ip = InitializationParser()
exp = ip.get_plugin('Experiment', category='general')
monitor = exp.find('monitor')
if monitor is not None:
if to_bool(monitor.get('enabled')):
host, port, kind = None, None, None
comms = monitor.find('communications')
host = comms.find('host')
port = comms.find('port')
kind = comms.find('kind')
if host is not None:
host = host.text # if host else 'localhost'
if port is not None:
port = int(port.text) # if port else 1061
if kind is not None:
kind = kind.text
mon = RemoteAutomatedRunMonitor(host, port, kind, name=monitor.text.strip())
else:
mon = AutomatedRunMonitor()
self.debug('Automated run monitor {}'.format(mon))
if mon is not None:
# mon.configuration_dir_name = paths.monitors_dir
isok = mon.load()
if isok:
return mon
else:
self.warning(
'no automated run monitor avaliable. Make sure config file is located at setupfiles/monitors/automated_run_monitor.cfg')
def _pyscript_runner_default(self):
if self.mode == 'client':
# em = self.extraction_line_manager
ip = InitializationParser()
elm = ip.get_plugin('Experiment', category='general')
runner = elm.find('runner')
host, port, kind = None, None, None
if runner is not None:
comms = runner.find('communications')
host = comms.find('host')
port = comms.find('port')
kind = comms.find('kind')
if host is not None:
host = host.text # if host else 'localhost'
if port is not None:
port = int(port.text) # if port else 1061
kind = kind.text # if kind else 'udp'
runner = RemotePyScriptRunner(host, port, kind)
else:
runner = PyScriptRunner()
return runner
def _manager_factory(self):
"""
"""
ip = InitializationParser()
plugin = ip.get_plugin(self.klass[1].replace('Manager', ''), category='hardware')
mode = ip.get_parameter(plugin, 'mode')
if mode == 'client':
klass = ip.get_parameter(plugin, 'klass')
if klass is None:
klass = 'PychronLaserManager'
pkg = 'pychron.lasers.laser_managers.pychron_laser_manager'
try:
tag = ip.get_parameter(plugin, 'communications', element=True)
# tag = plugin.find('communications')
params = dict()
for attr in ['host', 'port', 'kind']:
try:
params[attr] = tag.find(attr).text.strip()
except Exception, e:
print 'client comms fail', attr, e
except Exception, e:
print 'client comms fail', e
params['name'] = self.name
factory = __import__(pkg, fromlist=[klass])
m = getattr(factory, klass)(**params)
def _sources_default(self):
ip = InitializationParser()
plugin = ip.get_plugin(self.task_name.replace(' ', ''),
category='hardware')
source = ip.get_parameter(plugin, 'video_source')
rs = []
if source:
rs = [(source, self.task_name)]
return rs
def _sources_default(self):
ip = InitializationParser()
plugin = ip.get_plugin(self.task_name.replace(' ', ''),
category='hardware')
source = ip.get_parameter(plugin, 'video_source')
rs = []
if source:
rs = [(source, self.task_name)]
return rs
def get_hardware_plugins():
ip = InitializationParser()
ps = []
if 'hardware' in ip.get_categories():
from pychron.hardware.tasks.hardware_plugin import HardwarePlugin
if ip.get_plugins('hardware'):
ps = [HardwarePlugin(), ]
return ps
def _factory(self):
from pychron.initialization_parser import InitializationParser
ip = InitializationParser()
try:
plugin = ip.get_plugin('ExtractionLine', category='hardware')
mode = ip.get_parameter(plugin, 'mode')
# mode = plugin.get('mode')
except AttributeError:
# no epxeriment plugin defined
mode = 'normal'
elm = ExtractionLineManager(mode=mode)
elm.bind_preferences()
return elm
def _factory(self):
from pychron.initialization_parser import InitializationParser
ip = InitializationParser()
try:
plugin = ip.get_plugin('ExtractionLine', category='hardware')
mode = ip.get_parameter(plugin, 'mode')
# mode = plugin.get('mode')
except AttributeError:
# no epxeriment plugin defined
mode = 'normal'
elm = ExtractionLineManager(mode=mode)
elm.bind_preferences()
return elm
def _manager_factory(self):
from pychron.experiment.experimentor import Experimentor
from pychron.initialization_parser import InitializationParser
ip = InitializationParser()
plugin = ip.get_plugin('Experiment', category='general')
mode = ip.get_parameter(plugin, 'mode')
app = None
if self.window:
app = self.window.application
exp = Experimentor(application=app,
mode=mode)
return exp
def _processors_default(self):
ps = dict()
ip = InitializationParser()
hosts = []
# load the hosts file
p = os.path.join(paths.setup_dir, 'hosts')
if os.path.isfile(p):
with open(p, 'r') as f:
hosts = [l.strip() for l in f if l.strip()]
for pi in ip.get_processors():
cp = self._command_processor_factory(path=pi)
cp._hosts = hosts
ps[cp.name] = cp
return ps
def build_globals(debug):
from pychron.initialization_parser import InitializationParser
ip = InitializationParser()
from pychron.globals import globalv
globalv.build(ip)
globalv.debug = debug
def _processors_default(self):
ps = dict()
ip = InitializationParser()
hosts = []
# load the hosts file
p = os.path.join(paths.setup_dir, 'hosts')
if os.path.isfile(p):
with open(p, 'r') as f:
hosts = [l.strip() for l in f if l.strip()]
for pi in ip.get_processors():
cp = self._command_processor_factory(path=pi)
cp._hosts = hosts
ps[cp.name] = cp
return ps
def _load_servers(self):
'''
'''
# get server names
ip = InitializationParser()
names = ip.get_servers()
if names:
for s in names:
pn = '{}-processor'.format(s)
cp = self._command_processor_factory(name=pn)
cp.manager = self
cp.bootstrap()
self.processors[pn] = cp
e = RemoteCommandServer(name=s,
configuration_dir_name='servers',
processor=cp)
e.bootstrap()
self.servers.append(e)
def _load_servers(self):
'''
'''
# get server names
ip = InitializationParser()
names = ip.get_servers()
if names:
for s in names:
pn = '{}-processor'.format(s)
cp = self._command_processor_factory(name=pn)
cp.manager = self
cp.bootstrap()
self.processors[pn] = cp
e = RemoteCommandServer(name=s,
configuration_dir_name='servers',
processor=cp
)
e.bootstrap()
self.servers.append(e)
def bind_preferences(self, cp):
try:
bind_preference(self, 'system_lock',
'pychron.hardware.enable_system_lock')
bind_preference(cp, 'system_lock',
'pychron.hardware.enable_system_lock')
bind_preference(cp, 'system_lock_address',
'pychron.hardware.system_lock_address')
bind_preference(cp, 'system_lock_name',
'pychron.hardware.system_lock_name')
# ip = InitializationParser(os.path.join(setup_dir, 'initialization.xml'))
ip = InitializationParser()
names = []
hosts = dict()
for name, host in ip.get_systems():
names.append(name)
hosts[name] = host
pref = self.application.preferences
pref.set('pychron.hardware.system_lock_names', names)
pref.set('pychron.hardware.system_lock_addresses', hosts)
name = pref.get('pychron.hardware.system_lock_name')
try:
if name:
pref.set('pychron.hardware.system_lock_address',
hosts[name.strip("'").lower()])
else:
pref.set('pychron.hardware.system_lock_address',
hosts[names[0].lower()])
except Exception, err:
pass
# import traceback
# traceback.print_exc()
# print 'system lock exception', err
pref.save()
def _manager_factory(self):
"""
"""
ip = InitializationParser()
plugin = ip.get_plugin(self.klass[1].replace('Manager', ''),
category='hardware')
mode = ip.get_parameter(plugin, 'mode')
if mode == 'client':
klass = ip.get_parameter(plugin, 'klass')
if klass is None:
klass = 'PychronLaserManager'
pkg = 'pychron.lasers.laser_managers.pychron_laser_manager'
try:
tag = ip.get_parameter(plugin, 'communications', element=True)
# tag = plugin.find('communications')
params = dict()
for attr in ['host', 'port', 'kind']:
try:
params[attr] = tag.find(attr).text.strip()
except Exception, e:
print 'client comms fail', attr, e
except Exception, e:
print 'client comms fail', e
params['name'] = self.name
factory = __import__(pkg, fromlist=[klass])
m = getattr(factory, klass)(**params)
def _monitor_factory(self):
mon = None
isok = True
self.debug('Experiment Executor mode={}'.format(self.mode))
if self.mode == 'client':
ip = InitializationParser()
exp = ip.get_plugin('Experiment', category='general')
monitor = exp.find('monitor')
if monitor is not None:
if to_bool(monitor.get('enabled')):
host, port, kind = None, None, None
comms = monitor.find('communications')
host = comms.find('host')
port = comms.find('port')
kind = comms.find('kind')
if host is not None:
host = host.text # if host else 'localhost'
if port is not None:
port = int(port.text) # if port else 1061
if kind is not None:
kind = kind.text
mon = RemoteAutomatedRunMonitor(host,
port,
kind,
name=monitor.text.strip())
else:
mon = AutomatedRunMonitor()
self.debug('Automated run monitor {}'.format(mon))
if mon is not None:
# mon.configuration_dir_name = paths.monitors_dir
isok = mon.load()
if isok:
return mon
else:
self.warning(
'no automated run monitor avaliable. Make sure config file is located at setupfiles/monitors/automated_run_monitor.cfg'
)
def bind_preferences(self, cp):
try:
bind_preference(self, 'system_lock', 'pychron.hardware.enable_system_lock')
bind_preference(cp, 'system_lock', 'pychron.hardware.enable_system_lock')
bind_preference(cp, 'system_lock_address', 'pychron.hardware.system_lock_address')
bind_preference(cp, 'system_lock_name', 'pychron.hardware.system_lock_name')
# ip = InitializationParser(os.path.join(setup_dir, 'initialization.xml'))
ip = InitializationParser()
names = []
hosts = dict()
for name, host in ip.get_systems():
names.append(name)
hosts[name] = host
pref = self.application.preferences
pref.set('pychron.hardware.system_lock_names', names)
pref.set('pychron.hardware.system_lock_addresses', hosts)
name = pref.get('pychron.hardware.system_lock_name')
try:
if name:
pref.set('pychron.hardware.system_lock_address',
hosts[name.strip("'").lower()])
else:
pref.set('pychron.hardware.system_lock_address',
hosts[names[0].lower()])
except Exception, err:
pass
# import traceback
# traceback.print_exc()
# print 'system lock exception', err
pref.save()
def get_user_plugins():
"""
"""
# append plugins dir to the sys path
# sys.path.append(plugins_dir)
plugins = []
ps = InitializationParser().get_plugins()
core_added = False
for p in ps:
# if laser plugin add CoreLaserPlugin
if p in ('FusionsCO2', 'FusionsDiode'):
plugin = get_plugin('CoreLaserPlugin')
if plugin and not core_added:
core_added = True
plugins.append(plugin)
plugin = get_plugin(p)
if plugin:
plugins.append(plugin)
return plugins
def __init__(self, *args, **kw):
super(Initializer, self).__init__(*args, **kw)
self.clear()
self.cnt = 0
self.parser = InitializationParser()
class Initializer(Loggable):
'''
'''
pd = None
name = 'Initializer'
application = Any
device_prefs = Any
def __init__(self, *args, **kw):
super(Initializer, self).__init__(*args, **kw)
self.clear()
self.cnt = 0
self.parser = InitializationParser()
def clear(self):
self.init_list = []
self.application = None
def add_initialization(self, a):
"""
"""
self.debug('add initialization {}'.format(a))
ilist = self.init_list
ilist.append(a)
def run(self, application=None):
self.application = application
ok = True
self.info('Running Initializer')
nsteps = 1
for idict in self.init_list:
nsteps += self.get_nsteps(**idict)
self.load_progress(nsteps)
for idict in self.init_list:
ok = self._run_(**idict)
if not ok:
break
msg = ('Complete' if ok else 'Failed')
self.info('Initialization {}'.format(msg))
if self.pd is not None:
self.pd.update(self.pd.max)
if self.pd.progress_bar:
self.pd.close()
return ok
def info(self, msg, **kw):
pd = self.pd
if pd is not None:
# offset = pd.progress_bar.control.GetValue()
offset = pd.get_value()
if offset == pd.max - 1:
pd.max += 1
pd.change_message(msg)
# pd.update(offset + 1)
# (cont, skip) = pd.update(offset + 1)
# if not cont or skip:
# return
# time.sleep(0.1)
super(Initializer, self).info(msg, **kw)
def get_nsteps(self, name=None, manager=None, plugin_name=None):
parser = self.parser
if plugin_name is None:
# remove manager from name
idx = name.find('_manager')
if idx is not -1:
name = name[:idx]
mp = parser.get_plugin(name)
else:
mp = parser.get_manager(name, plugin_name)
if mp is None:
mp = parser.get_root().find('plugins/{}'.format(name))
ns = 0
if mp is not None:
ns += (2 * (len(parser.get_managers(mp)) + 1))
ns += (3 * (len(parser.get_devices(mp)) + 1))
ns += (len(parser.get_flags(mp)) + 1)
ns += (len(parser.get_timed_flags(mp)) + 1)
return ns
def _run_(
self,
name=None,
device_dir=None,
manager=None,
plugin_name=None,
):
'''
'''
if device_dir is None:
device_dir = paths.device_dir
parser = self.parser
if manager is not None:
self.info('Manager loading {}'.format(name))
manager.application = self.application
manager.load()
else:
return False
managers = []
devices = []
flags = []
timed_flags = []
if plugin_name is None:
# remove manager from name
idx = name.find('_manager')
if idx is not -1:
name = name[:idx]
mp = parser.get_plugin(name)
else:
mp = parser.get_manager(name, plugin_name)
if mp is None:
mp = parser.get_root().find('plugins/{}'.format(name))
if mp is not None:
if not globalv.ignore_required:
if not self._check_required(mp):
return False
managers = parser.get_managers(mp)
devices = parser.get_devices(mp)
flags = parser.get_flags(mp)
timed_flags = parser.get_timed_flags(mp)
valve_flags_attrs = []
valve_flags = parser.get_valve_flags(mp, element=True)
if valve_flags:
for vf in valve_flags:
vs = vf.find('valves')
if vs:
vs = vs.split(',')
valve_flags_attrs.append((vf.text.strip(), vs))
# set rpc server
mode, _, port = parser.get_rpc_params(mp)
if port and mode != 'client':
manager.load_rpc_server(port)
if managers:
self.info('loading managers - {}'.format(', '.join(managers)))
manager.name = name
self.load_managers(manager, managers, device_dir)
if devices:
self.info('loading devices - {}'.format(', '.join(devices)))
self.load_devices(manager, name, devices, plugin_name)
if flags:
self.info('loading flags - {}'.format(', '.join(flags)))
self.load_flags(manager, flags)
if timed_flags:
self.info('loading timed flags - {}'.format(','.join(timed_flags)))
self.load_timed_flags(manager, timed_flags)
if valve_flags:
self.info('loading valve flags - {}'.format(','.join(timed_flags)))
self.load_timed_flags(manager, valve_flags_attrs)
if manager is not None:
self.info('finish {} loading'.format(name))
manager.finish_loading()
return True
def load_flags(self, manager, flags):
for f in flags:
self.info('loading {}'.format(f))
manager.add_flag(f)
def load_timed_flags(self, manager, flags):
for f in flags:
self.info('loading {}'.format(f))
manager.add_timed_flag(f)
def load_valve_flags(self, manager, flags):
for f, v in flags:
self.info('loading {}, valves={}'.format(f, v))
manager.add_valve_flag(f, v)
def load_managers(
self,
manager,
managers,
device_dir,
):
for mi in managers:
man = None
if mi == '':
continue
self.info('load {}'.format(mi))
mode, host, port = self.parser.get_rpc_params((mi, manager.name))
remote = mode == 'client'
try:
man = getattr(manager, mi)
if man is None:
man = manager.create_manager(mi,
host=host,
port=port,
remote=remote)
except AttributeError, e:
print 'initializaer', e
# self.warning(e)
try:
man = manager.create_manager(mi,
host=host,
port=port,
remote=remote)
except Exception:
import traceback
traceback.print_exc()
if man is None:
self.debug('trouble creating manager {}'.format(mi))
break
if self.application is not None:
# register this manager as a service
man.application = self.application
self.application.register_service(type(man), man)
d = dict(name=mi,
device_dir=device_dir,
manager=man,
plugin_name=manager.name)
self.add_initialization(d)
class Initializer(Loggable):
'''
'''
pd = None
name = 'Initializer'
application = Any
device_prefs = Any
def __init__(self, *args, **kw):
super(Initializer, self).__init__(*args, **kw)
self.clear()
self.cnt = 0
self.parser = InitializationParser()
def clear(self):
self.init_list = []
self.application = None
def add_initialization(self, a):
"""
"""
self.debug('add initialization {}'.format(a))
ilist = self.init_list
ilist.append(a)
def run(self, application=None):
self.application = application
ok = True
self.info('Running Initializer')
nsteps = 1
for idict in self.init_list:
nsteps += self.get_nsteps(**idict)
self.load_progress(nsteps)
for idict in self.init_list:
ok = self._run_(**idict)
if not ok:
break
msg = ('Complete' if ok else 'Failed')
self.info('Initialization {}'.format(msg))
if self.pd is not None:
self.pd.update(self.pd.max)
if self.pd.progress_bar:
self.pd.close()
return ok
def info(self, msg, **kw):
pd = self.pd
if pd is not None:
# offset = pd.progress_bar.control.GetValue()
offset = pd.get_value()
if offset == pd.max - 1:
pd.max += 1
pd.change_message(msg)
# pd.update(offset + 1)
# (cont, skip) = pd.update(offset + 1)
# if not cont or skip:
# return
# time.sleep(0.1)
super(Initializer, self).info(msg, **kw)
def get_nsteps(self, name=None, manager=None, plugin_name=None):
parser = self.parser
if plugin_name is None:
# remove manager from name
idx = name.find('_manager')
if idx is not -1:
name = name[:idx]
mp = parser.get_plugin(name)
else:
mp = parser.get_manager(name, plugin_name)
if mp is None:
mp = parser.get_root().find('plugins/{}'.format(name))
ns = 0
if mp is not None:
ns += (2 * (len(parser.get_managers(mp)) + 1))
ns += (3 * (len(parser.get_devices(mp)) + 1))
ns += (len(parser.get_flags(mp)) + 1)
ns += (len(parser.get_timed_flags(mp)) + 1)
return ns
def _run_(
self,
name=None,
device_dir=None,
manager=None,
plugin_name=None,
):
'''
'''
if device_dir is None:
device_dir = paths.device_dir
parser = self.parser
if manager is not None:
self.info('Manager loading {}'.format(name))
manager.application = self.application
manager.load()
else:
return False
managers = []
devices = []
flags = []
timed_flags = []
if plugin_name is None:
# remove manager from name
idx = name.find('_manager')
if idx is not -1:
name = name[:idx]
mp = parser.get_plugin(name)
else:
mp = parser.get_manager(name, plugin_name)
if mp is None:
mp = parser.get_root().find('plugins/{}'.format(name))
if mp is not None:
if not globalv.ignore_required:
if not self._check_required(mp):
return False
managers = parser.get_managers(mp)
devices = parser.get_devices(mp)
flags = parser.get_flags(mp)
timed_flags = parser.get_timed_flags(mp)
valve_flags_attrs = []
valve_flags = parser.get_valve_flags(mp, element=True)
if valve_flags:
for vf in valve_flags:
vs = vf.find('valves')
if vs:
vs = vs.split(',')
valve_flags_attrs.append((vf.text.strip(), vs))
# set rpc server
mode, _, port = parser.get_rpc_params(mp)
if port and mode != 'client':
manager.load_rpc_server(port)
if managers:
self.info('loading managers - {}'.format(', '.join(managers)))
manager.name = name
self.load_managers(manager, managers, device_dir)
if devices:
self.info('loading devices - {}'.format(', '.join(devices)))
self.load_devices(manager, name, devices, plugin_name)
if flags:
self.info('loading flags - {}'.format(', '.join(flags)))
self.load_flags(manager, flags)
if timed_flags:
self.info('loading timed flags - {}'.format(','.join(timed_flags)))
self.load_timed_flags(manager, timed_flags)
if valve_flags:
self.info('loading valve flags - {}'.format(','.join(timed_flags)))
self.load_timed_flags(manager, valve_flags_attrs)
if manager is not None:
self.info('finish {} loading'.format(name))
manager.finish_loading()
return True
def load_flags(self, manager, flags):
for f in flags:
self.info('loading {}'.format(f))
manager.add_flag(f)
def load_timed_flags(self, manager, flags):
for f in flags:
self.info('loading {}'.format(f))
manager.add_timed_flag(f)
def load_valve_flags(self, manager, flags):
for f, v in flags:
self.info('loading {}, valves={}'.format(f, v))
manager.add_valve_flag(f, v)
def load_managers(
self,
manager,
managers,
device_dir, ):
for mi in managers:
man = None
if mi == '':
continue
self.info('load {}'.format(mi))
mode, host, port = self.parser.get_rpc_params((mi, manager.name))
remote = mode == 'client'
try:
man = getattr(manager, mi)
if man is None:
man = manager.create_manager(mi, host=host,
port=port, remote=remote)
except AttributeError, e:
print 'initializaer', e
# self.warning(e)
try:
man = manager.create_manager(mi,
host=host,
port=port, remote=remote)
except Exception:
import traceback
traceback.print_exc()
if man is None:
self.debug('trouble creating manager {}'.format(mi))
break
if self.application is not None:
# register this manager as a service
man.application = self.application
self.application.register_service(type(man), man)
d = dict(name=mi, device_dir=device_dir, manager=man,
plugin_name=manager.name)
self.add_initialization(d)
def __init__(self, *args, **kw):
super(Initializer, self).__init__(*args, **kw)
self.clear()
self.cnt = 0
self.parser = InitializationParser()
