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 _manager_factory(self):
"""
"""
ip = InitializationParser()
plugin = ip.get_plugin(self.klass[1].replace('Manager', ''),
category='hardware')
mode = ip.get_parameter(plugin, 'mode')
self.mode = mode
klass = ip.get_parameter(plugin, 'klass')
if klass is None and mode == 'client':
klass = 'PychronLaserManager'
pkg = 'pychron.lasers.laser_managers.pychron_laser_manager'
factory = __import__(pkg, fromlist=[klass])
klassfactory = getattr(factory, klass)
else:
factory = __import__(self.klass[0], fromlist=[self.klass[1]])
klassfactory = getattr(factory, self.klass[1])
params = dict(name=self.name)
if mode == 'client':
try:
tag = ip.get_parameter(plugin, 'communications', element=True)
for attr in [
'host', 'port', 'kind', 'message_frame',
('use_end', to_bool)
]:
func = None
if isinstance(attr, tuple):
attr, func = attr
try:
elem = tag.find(attr)
if elem is not None:
v = elem.text.strip()
if func:
v = func(v)
params[attr] = v
else:
self.debug(
'No communications attribute {}'.format(attr))
except Exception as e:
print('client comms fail a', attr, e)
except Exception as e:
print('client comms fail b', e)
m = klassfactory(**params)
m.mode = mode
m.bootstrap()
m.plugin_id = self.id
m.bind_preferences(self.id)
return m
def _manager_factory(self):
"""
"""
ip = InitializationParser()
plugin = ip.get_plugin(self.klass[1].replace('Manager', ''), category='hardware')
mode = ip.get_parameter(plugin, 'mode')
klass = ip.get_parameter(plugin, 'klass')
if klass is None and mode == 'client':
klass = 'PychronLaserManager'
pkg = 'pychron.lasers.laser_managers.pychron_laser_manager'
factory = __import__(pkg, fromlist=[klass])
klassfactory = getattr(factory, klass)
else:
factory = __import__(self.klass[0], fromlist=[self.klass[1]])
klassfactory = getattr(factory, self.klass[1])
params = dict(name=self.name)
if mode == 'client':
try:
tag = ip.get_parameter(plugin, 'communications', element=True)
for attr in ['host', 'port', 'kind', 'message_frame', ('use_end', to_bool)]:
func = None
if isinstance(attr, tuple):
attr, func = attr
try:
elem = tag.find(attr)
if elem is not None:
v = elem.text.strip()
if func:
v = func(v)
params[attr] = v
else:
self.debug('No communications attribute {}'.format(attr))
except Exception as e:
print('client comms fail a', attr, e)
except Exception as e:
print('client comms fail b', e)
m = klassfactory(**params)
m.mode = mode
m.bootstrap()
m.plugin_id = self.id
m.bind_preferences(self.id)
return m
def _manager_default(self):
from pychron.envisage.initialization.initialization_parser import \
InitializationParser
ip = InitializationParser()
plugin = ip.get_plugin('Experiment', category='general')
mode = ip.get_parameter(plugin, 'mode')
proto = 'pychron.database.isotope_database_manager.IsotopeDatabaseManager'
iso_db_man = self.application.get_service(proto)
# experimentor.iso_db_man = iso_db_man
proto = 'pychron.dvc.dvc.DVC'
dvc = self.application.get_service(proto)
# experimentor.dvc = dvc
experimentor = Experimentor(application=self.application,
mode=mode,
dvc=dvc,
iso_db_man=iso_db_man)
experimentor.executor.set_managers()
experimentor.executor.bind_preferences()
return experimentor
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 _manager_factory(self):
"""
"""
ip = InitializationParser()
plugin = ip.get_plugin(self.klass[1].replace('Manager', ''), category='hardware')
mode = ip.get_parameter(plugin, 'mode')
klass = ip.get_parameter(plugin, 'klass')
if klass is None and mode == 'client':
klass = 'PychronLaserManager'
pkg = 'pychron.lasers.laser_managers.api'
factory = __import__(pkg, fromlist=[klass])
klassfactory = getattr(factory, klass)
else:
factory = __import__(self.klass[0], fromlist=[self.klass[1]])
klassfactory = getattr(factory, self.klass[1])
params = dict(name=self.name)
if mode == 'client':
try:
tag = ip.get_parameter(plugin, 'communications', element=True)
for attr in ['host', 'port', 'kind', 'message_frame', ('use_end', to_bool)]:
func = None
if isinstance(attr, tuple):
attr, func = attr
try:
v = tag.find(attr).text.strip()
if func:
v = func(v)
params[attr] = v
except Exception, e:
print 'client comms fail a', attr, e
except Exception, e:
print 'client comms fail b', e
def _factory(self):
from pychron.envisage.initialization.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 _experimentor_default(self):
# from pychron.experiment.experimentor import Experimentor
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=self.application,
mode=mode)
return exp
def _manager_default(self):
from pychron.envisage.initialization.initialization_parser import \
InitializationParser
ip = InitializationParser()
plugin = ip.get_plugin('Experiment', category='general')
mode = ip.get_parameter(plugin, 'mode')
man = Experimentor(application=self.application, mode=mode)
iso = 'pychron.database.isotope_database_manager.IsotopeDatabaseManager'
manager = self.application.get_service(iso)
dvc = self.application.get_service('pychron.dvc.dvc.DVC')
if dvc:
man.dvc = dvc
man.iso_db_manager = manager
man.executor.set_managers()
man.executor.bind_preferences()
return man
def _manager_default(self):
from pychron.envisage.initialization.initialization_parser import \
InitializationParser
ip = InitializationParser()
plugin = ip.get_plugin('Experiment', category='general')
mode = ip.get_parameter(plugin, 'mode')
proto = 'pychron.database.isotope_database_manager.IsotopeDatabaseManager'
iso_db_man = self.application.get_service(proto)
# experimentor.iso_db_man = iso_db_man
proto = 'pychron.dvc.dvc.DVC'
dvc = self.application.get_service(proto)
# experimentor.dvc = dvc
experimentor = Experimentor(application=self.application,
mode=mode, dvc=dvc, iso_db_man=iso_db_man)
experimentor.executor.set_managers()
experimentor.executor.bind_preferences()
return experimentor
def _manager_default(self):
from pychron.envisage.initialization.initialization_parser import \
InitializationParser
ip = InitializationParser()
plugin = ip.get_plugin('Experiment', category='general')
mode = ip.get_parameter(plugin, 'mode')
man = Experimentor(application=self.application,
mode=mode)
iso = 'pychron.database.isotope_database_manager.IsotopeDatabaseManager'
manager = self.application.get_service(iso)
dvc = self.application.get_service('pychron.dvc.dvc.DVC')
if dvc:
man.dvc = dvc
man.iso_db_manager = manager
man.executor.set_managers()
man.executor.bind_preferences()
return man
class Initializer(Loggable):
name = 'Initializer'
_init_list = List
_parser = Any
_pd = Any
def add_initialization(self, a):
"""
"""
self.debug('add initialization {}'.format(a))
self._init_list.append(a)
def run(self, application=None):
self._parser = InitializationParser()
self.info('Initialization Path: {}'.format(self._parser.path))
self.application = application
ok = True
self.info('Running Initializer')
nsteps = sum([self._get_nsteps(idict['plugin_name']) for idict in self._init_list]) + 1
pd = self._setup_progress(nsteps)
try:
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))
pd.close()
except BaseException as e:
import traceback
traceback.print_exc()
self.debug('Initializer Exception: {}'.format(e))
raise e
return ok
def info(self, msg, **kw):
pd = self._pd
if pd is not None:
offset = pd.get_value()
if offset == pd.max - 1:
pd.max += 1
pd.change_message(msg)
super(Initializer, self).info(msg, **kw)
def _run(self, name=None, manager=None, plugin_name=None):
parser = self._parser
if manager is not None:
self.info('Manager loading {}'.format(name))
manager.application = self.application
manager.load()
else:
return False
managers = []
if plugin_name:
mp = self._get_plugin(plugin_name)
else:
mp, name = self._get_plugin_by_name(name)
if mp is not None:
if not globalv.ignore_initialization_required:
if not self._check_required(mp):
return False
managers = parser.get_managers(mp)
if managers:
self.info('loading managers - {}'.format(', '.join(managers)))
manager.name = name
self._load_managers(manager, managers, plugin_name)
self._load_elements(mp, manager, name, plugin_name)
if manager is not None:
self.info('finish {} loading'.format(name))
manager.finish_loading()
return True
def _load_elements(self, element, manager, name, plugin_name):
mp = element
parser = self._parser
devices = parser.get_devices(mp)
flags = parser.get_flags(mp)
timed_flags = parser.get_timed_flags(mp)
valve_flags = parser.get_valve_flags(mp, element=True)
valve_flags_attrs = []
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))
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_attrs:
self.info('loading valve flags - {}'.format(','.join(valve_flags_attrs)))
self._load_valve_flags(manager, valve_flags_attrs)
# loaders
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_devices(self, manager, name, devices, plugin_name, ):
"""
"""
devs = []
if manager is None:
return
for device in devices:
if not device:
continue
pdev = self._parser.get_device(name, device, plugin_name, element=True)
dev_class = pdev.find('klass')
if dev_class is not None:
dev_class = dev_class.text.strip()
try:
dev = getattr(manager, device)
if dev is None:
dev = manager.create_device(device,
dev_class=dev_class)
else:
if dev_class and dev.__class__.__name__ != dev_class:
dev = manager.create_device(device, dev_class=dev_class, obj=dev)
except AttributeError:
dev = manager.create_device(device, dev_class=dev_class)
if dev is None:
self.warning('No device for {}'.format(device))
continue
self.info('loading {}'.format(dev.name))
dev.application = self.application
if dev.load():
# register the device
if self.application is not None:
# display with the HardwareManager
self.info('Register device name={}, {}'.format(dev.name, dev))
self.application.register_service(ICoreDevice, dev, {'display': True})
devs.append(dev)
self.info('opening {}'.format(dev.name))
if not dev.open(prefs=self.device_prefs):
self.info('failed connecting to {}'.format(dev.name))
else:
self.info('failed loading {}'.format(dev.name))
for od in devs:
self.info('Initializing {}'.format(od.name))
result = od.initialize(progress=self._pd)
if result is not True:
self.warning('Failed setting up communications to {}'.format(od.name))
od.set_simulation(True)
elif result is None:
self.debug('{} initialize function does not return a boolean'.format(od.name))
raise NotImplementedError
od.application = self.application
od.post_initialize()
manager.devices.append(od)
def _load_managers(self, manager, managers, plugin_name):
for mi in managers:
man = None
self.info('load {}'.format(mi))
try:
man = getattr(manager, mi)
if man is None:
man = manager.create_manager(mi)
except AttributeError as e:
self.warning(e)
try:
man = manager.create_manager(mi)
except InitializerError:
import traceback
traceback.print_exc()
if man is None:
self.debug('trouble creating manager {}'.format(mi))
continue
if self.application is not None:
# register this manager as a service
man.application = self.application
self.application.register_service(type(man), man)
man.load()
element = self._get_manager(mi, plugin_name)
if not globalv.ignore_initialization_required:
if not self._check_required(element):
return False
self._load_elements(element, man, mi, plugin_name)
self.info('finish {} loading'.format(mi))
man.finish_loading()
# helpers
def _setup_progress(self, n):
"""
n: int, initialize progress dialog with n steps
return a myProgressDialog object
"""
pd = myProgressDialog(max=n, message='Welcome',
position=(100, 100),
size=(500, 50))
self._pd = pd
self._pd.open()
return pd
def _check_required(self, subtree):
# check the subtree has all required devices enabled
devs = self._parser.get_devices(subtree, all_=True, element=True)
for di in devs:
required = True
req = self._parser.get_parameter(di, 'required')
if req:
required = to_bool(req)
enabled = to_bool(di.get('enabled'))
if required and not enabled:
name = di.text.strip().upper()
msg = '''Device {} is REQUIRED but is not ENABLED.
Do you want to quit to enable {} in the Initialization File?'''.format(name, name)
result = self.confirmation_dialog(msg, title='Quit Pychron')
if result:
raise InitializerError()
return True
def _get_manager(self, name, plugin_name):
parser = self._parser
man = parser.get_manager(name, plugin_name)
return man
def _get_plugin(self, name):
parser = self._parser
mp = parser.get_plugin(name)
return mp
def _get_nsteps(self, plugin_name):
parser = self._parser
mp = self._get_plugin(plugin_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
class Initializer(Loggable):
name = 'Initializer'
init_list = List
parser = Any
pd = Any
def add_initialization(self, a):
"""
"""
self.debug('add initialization {}'.format(a))
self.init_list.append(a)
def run(self, application=None):
self.parser = InitializationParser()
self.info('Initialization Path: {}'.format(self.parser.path))
self.application = application
ok = True
self.info('Running Initializer')
nsteps = sum([self._get_nsteps(idict['plugin_name']) for idict in self.init_list])+1
pd = self._setup_progress(nsteps)
try:
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))
pd.close()
except BaseException as e:
import traceback
traceback.print_exc()
self.debug('Initializer Exception: {}'.format(e))
raise e
return ok
def info(self, msg, **kw):
pd = self.pd
if pd is not None:
offset = pd.get_value()
if offset == pd.max - 1:
pd.max += 1
pd.change_message(msg)
super(Initializer, self).info(msg, **kw)
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 = []
if plugin_name:
mp = self._get_plugin(plugin_name)
else:
mp, name = self._get_plugin_by_name(name)
if mp is not None:
if not globalv.ignore_initialization_required:
if not self._check_required(mp):
return False
managers = parser.get_managers(mp)
if managers:
self.info('loading managers - {}'.format(', '.join(managers)))
manager.name = name
self._load_managers(manager, managers, device_dir, plugin_name)
self._load_elements(mp, manager, name, plugin_name)
if manager is not None:
self.info('finish {} loading'.format(name))
manager.finish_loading()
return True
def _load_elements(self, element, manager, name, plugin_name):
mp = element
parser = self.parser
devices = parser.get_devices(mp)
flags = parser.get_flags(mp)
timed_flags = parser.get_timed_flags(mp)
valve_flags = parser.get_valve_flags(mp, element=True)
valve_flags_attrs = []
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))
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_attrs:
self.info('loading valve flags - {}'.format(','.join(valve_flags_attrs)))
self._load_valve_flags(manager, valve_flags_attrs)
# loaders
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_devices(self, manager, name, devices, plugin_name, ):
"""
"""
devs = []
if manager is None:
return
for device in devices:
if not device:
continue
pdev = self.parser.get_device(name, device, plugin_name, element=True)
dev_class = pdev.find('klass')
if dev_class is not None:
dev_class = dev_class.text.strip()
try:
dev = getattr(manager, device)
if dev is None:
dev = manager.create_device(device,
dev_class=dev_class)
else:
if dev_class and dev.__class__.__name__ != dev_class:
dev = manager.create_device(device,
dev_class=dev_class,
obj=dev)
except AttributeError:
dev = manager.create_device(device, dev_class=dev_class)
if dev is None:
self.warning('No device for {}'.format(device))
continue
self.info('loading {}'.format(dev.name))
dev.application = self.application
if dev.load():
# register the device
if self.application is not None:
# display with the HardwareManager
self.info('Regisiter device name={}, {}'.format(dev.name, dev))
self.application.register_service(ICoreDevice, dev,
{'display': True})
devs.append(dev)
self.info('opening {}'.format(dev.name))
if not dev.open(prefs=self.device_prefs):
self.info('failed connecting to {}'.format(dev.name))
else:
self.info('failed loading {}'.format(dev.name))
for od in devs:
self.info('Initializing {}'.format(od.name))
result = od.initialize(progress=self.pd)
if result is not True:
self.warning('Failed setting up communications to {}'.format(od.name))
od.set_simulation(True)
elif result is None:
self.debug('{} initialize function does not return a boolean'.format(od.name))
raise NotImplementedError
od.application = self.application
od.post_initialize()
manager.devices.append(od)
def _load_managers(self,
manager,
managers,
device_dir,
plugin_name):
for mi in managers:
man = None
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)
except AttributeError as e:
self.warning(e)
try:
man = manager.create_manager(mi)
except Exception:
import traceback
traceback.print_exc()
if man is None:
self.debug('trouble creating manager {}'.format(mi))
continue
if self.application is not None:
# register this manager as a service
man.application = self.application
self.application.register_service(type(man), man)
man.load()
element = self._get_manager(mi, plugin_name)
if not globalv.ignore_initialization_required:
if not self._check_required(element):
return False
self._load_elements(element, man, mi, plugin_name)
self.info('finish {} loading'.format(mi))
man.finish_loading()
# helpers
def _setup_progress(self, n):
"""
n: int, initialize progress dialog with n steps
return a myProgressDialog object
"""
pd = myProgressDialog(max=n, message='Welcome',
position=(100, 100),
size=(500, 50))
self.pd = pd
self.pd.open()
return pd
def _check_required(self, subtree):
# check the subtree has all required devices enabled
devs = self.parser.get_devices(subtree, all_=True, element=True)
for di in devs:
required = True
req = self.parser.get_parameter(di, 'required')
if req:
required = req.strip().lower() == 'true'
enabled = di.get('enabled').lower() == 'true'
if required and not enabled:
name = di.text.strip().upper()
msg = '''Device {} is REQUIRED but is not ENABLED.
Do you want to quit to enable {} in the Initialization File?'''.format(name, name)
result = self.confirmation_dialog(msg, title='Quit Pychron')
if result:
raise InitializerError()
# os._exit(0)
return True
def _get_manager(self, name, plugin_name):
parser = self.parser
man = parser.get_manager(name, plugin_name)
return man
def _get_plugin(self, name):
parser = self.parser
mp = parser.get_plugin(name)
return mp
def _get_nsteps(self, plugin_name):
parser = self.parser
mp = self._get_plugin(plugin_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
