Exemplo n.º 1
0
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
Exemplo n.º 2
0
    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)
Exemplo n.º 3
0
    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
Exemplo n.º 7
0
 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
Exemplo n.º 8
0
 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
Exemplo n.º 9
0
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
Exemplo n.º 10
0
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
Exemplo n.º 11
0
    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
Exemplo n.º 12
0
    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
Exemplo n.º 13
0
    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
Exemplo n.º 14
0
    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
Exemplo n.º 16
0
    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)
Exemplo n.º 18
0
    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)
Exemplo n.º 19
0
    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()
Exemplo n.º 21
0
    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
Exemplo n.º 22
0
    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
Exemplo n.º 23
0
    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
Exemplo n.º 24
0
    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
Exemplo n.º 25
0
    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()
Exemplo n.º 26
0
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
Exemplo n.º 27
0
    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
Exemplo n.º 28
0
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
Exemplo n.º 29
0
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)
Exemplo n.º 30
0
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
Exemplo n.º 31
0
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
Exemplo n.º 32
0
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 =============================================
Exemplo n.º 33
0
    def __init__(self, *args, **kw):

        super(Initializer, self).__init__(*args, **kw)
        self.parser = InitializationParser()
        self.init_list = []