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 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 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 _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 _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 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 _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 _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 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 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 =============================================