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