def get_initialization_model(): ip = InitializationParser() rtree = load_plugin_tree() gtree = load_global_tree() for gi in ip.get_plugin_groups(): tree = get_tree(gi, rtree) if tree: ps = ip.get_plugins(gi, element=True) if ps: for pp in ps: plugin = get_plugin(pp.text.strip(), tree) if plugin: plugin.enabled = to_bool(pp.get('enabled')) for gi in ip.get_globals(): gv = gtree.get_value(gi.tag) if gv: gv.enabled = to_bool(gi.text.strip()) model = InitializationModel(trees=[gtree, rtree], path_name=os.path.basename(ip.path), parser=ip) model.init_hash() return model
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 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 _runner_factory(self): ip = InitializationParser() elm = ip.get_plugin('ClientExtractionLine', category='hardware') runner = elm.find('runner') if runner is None: self.warning_dialog('Script Runner is not configured in the Initialization file. See documentation') return host, port, kind, frame = None, None, None, None if runner is not None: comms = runner.find('communications') host = comms.find('host') port = comms.find('port') kind = comms.find('kind') frame = comms.find('message_frame') 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 # if kind else 'udp' if frame is not None: frame = frame.text runner = RemotePyScriptRunner(host, port, kind, frame) return runner
def _runner_factory(self): ip = InitializationParser() elm = ip.get_plugin('ClientExtractionLine', category='hardware') runner = elm.find('runner') if runner is None: self.warning_dialog( 'Script Runner is not configured in the Initialization file. See documentation' ) return host, port, kind, frame = None, None, None, None if runner is not None: comms = runner.find('communications') host = comms.find('host') port = comms.find('port') kind = comms.find('kind') frame = comms.find('message_frame') 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 # if kind else 'udp' if frame is not None: frame = frame.text runner = RemotePyScriptRunner(host, port, kind, frame) return runner
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 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.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 _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 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 _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 _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 _runner_factory(self): # get the extraction line manager's mode man = self._get_el_manager() if man is None: self.warning_dialog('No Extraction line manager available') mode = 'normal' else: mode = man.mode if mode == 'client': # em = self.extraction_line_manager from pychron.envisage.initialization.initialization_parser import InitializationParser 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 if kind is not None: kind = kind.text # if kind else 'udp' from pychron.pyscripts.pyscript_runner import RemotePyScriptRunner runner = RemotePyScriptRunner(host, port, kind) else: from pychron.pyscripts.pyscript_runner import PyScriptRunner runner = PyScriptRunner() return runner
def _bind_processor_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_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_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 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 build_globals(user, debug): try: from pychron.envisage.initialization.initialization_parser import InitializationParser except ImportError as e: from pyface.message_dialog import warning warning(None, str(e)) ip = InitializationParser() from pychron.globals import globalv globalv.build(ip) globalv.debug = debug globalv.username = user
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 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
class Initializer(Loggable): """ """ pd = None name = 'Initializer' application = Any device_prefs = Any init_list = None def __init__(self, *args, **kw): super(Initializer, self).__init__(*args, **kw) self.parser = InitializationParser() self.init_list = [] def add_initialization(self, a): """ """ self.debug('add initialization {}'.format(a)) self.init_list.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) pd = 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)) pd.close() 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 = [] devices = [] flags = [] timed_flags = [] valve_flags_attrs = [] mp, name = self._get_plugin(name, plugin_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 = 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_attrs: self.info('loading valve flags - {}'.format(','.join(valve_flags_attrs))) self._load_valve_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 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: 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)) continue 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): 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
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
def add_eggs(root): egg_path = os.path.join(root, 'pychron.pth') if os.path.isfile(egg_path): # use a pychron.pth to get additional egg paths with open(egg_path, 'r') as rfile: eggs = [ei.strip() for ei in rfile.read().split('\n')] eggs = [ei for ei in eggs if ei] for egg_name in eggs: # sys.path.insert(0, os.path.join(root, egg_name)) sys.path.append(os.path.join(root, egg_name)) print os.path.join(root, egg_name) def build_globals(debug): try: from pychron.envisage.initialization.initialization_parser import InitializationParser except ImportError, e: from pyface.message_dialog import warning warning(None, str(e)) ip = InitializationParser() from pychron.globals import globalv globalv.build(ip) globalv.debug = debug # ============= EOF =============================================
def __init__(self, *args, **kw): super(Initializer, self).__init__(*args, **kw) self.parser = InitializationParser() self.init_list = []