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 __init__(self, schema_identifier='', attrs=None):
        super(ConnectionFavoriteItem, self).__init__()
        self.schema_identifier = schema_identifier

        if attrs:
            attrs = attrs.split(',')
            try:
                self.name, self.kind, self.username, self.host, self.dbname, self.password = attrs
            except ValueError:
                try:
                    self.name, self.kind, self.username, self.host, self.dbname, self.password, enabled = attrs
                    self.enabled = to_bool(enabled)
                except ValueError:
                    try:
                        (self.name, self.kind, self.username, self.host, self.dbname,
                         self.password, enabled, default) = attrs

                        self.enabled = to_bool(enabled)
                        self.default = to_bool(default)
                    except ValueError:
                        (self.name, self.kind, self.username, self.host, self.dbname,
                         self.password, enabled, default, path) = attrs
                        self.enabled = to_bool(enabled)
                        self.default = to_bool(default)
                        self.path = path

            self.load_names()

 def wrapper(*args, **kw):
     r = func(*args, **kw)
     if r:
         r = to_bool(r.strip())
         if invert:
             r = not r
     return r

 def wrapper(*args, **kw):
     r = func(*args, **kw)
     if r:
         r = r.strip()
         r = to_bool(r)
         # r = to_bool(r[4:-4])
     return r

 def _get_db(self):
     if self.use_workspace:
         return self.workspace.index_db
     elif to_bool(self.application.preferences.get('pychron.dvc.enabled')):
         return self.application.get_service('pychron.dvc.dvc.DVC')
     else:
         return self.manager.db

    def _new_label(self, label, name, c,
                   layer=1,
                   origin=None, klass=None, **kw):
        if origin is None:
            ox, oy = 0, 0
        else:
            ox, oy = origin
        if klass is None:
            klass = Label
        x, y = 0, 0
        trans = label.find('translation')
        if trans is not None:
            x, y = map(float, trans.text.split(','))

        c = self._make_color(c)
        l = klass(ox + x, oy + y,
                  bgcolor=c,
                  use_border=to_bool(label.get('use_border', 'T')),
                  name=name,
                  text=label.text.strip(),
                  **kw)
        font = label.find('font')
        if font is not None:
            l.font = font.text.strip()

        self.add_item(l, layer=layer)
        return l

    def _load_booleans(self, header, args, params):

        for attr in ['autocenter',
                     'use_cdd_warming',
                     ('disable_between_positions', 'dis_btw_pos')]:
            v = self._get_attr_value(header, args, attr, cast=lambda x: to_bool(x.strip()))
            if v is not None:
                params[v[0]] = v[1]

    def _random_tip(self):
        if globalv.random_tip_enabled and to_bool(self.application.preferences.get('pychron.general.show_random_tip')):
            from pychron.envisage.tasks.tip_view import TipView

            t = random.choice(self.help_tips)

            tv = TipView(text=t)
            tv.edit_traits()

    def __init__(self, schema_identifier='', attrs=None, load_names=False):
        super(ConnectionFavoriteItem, self).__init__()
        self.schema_identifier = schema_identifier

        if attrs:
            attrs = attrs.split(',')
            try:
                (self.name, self.kind, self.username, self.host, self.dbname,
                 self.password, enabled, default, path) = attrs

            except ValueError:
                (self.name, self.kind, self.username, self.host, self.dbname,
                 self.password, enabled, default, self.path, self.organization,
                 self.meta_repo_name, self.meta_repo_dir) = attrs

            self.enabled = to_bool(enabled)
            self.default = to_bool(default)
            if load_names:
                self.load_names()

    def GoToHole(self, manager, hole, autocenter, *args):
        try:
            hole = int(hole)
            autocenter = to_bool(autocenter)

            err = manager.stage_manager.move_to_hole(str(hole),
                                                     correct_position=autocenter)
        except (ValueError, TypeError):
            err = InvalidArgumentsErrorCode('GoToHole', (hole, autocenter))

        return self.error_response(err)

 def load(self):
     p = paths.task_extensions_file
     if os.path.isfile(p):
         with open(p, 'r') as rfile:
             yl = yaml.load(rfile)
             for te in self.task_extensions:
                 yd = next((d for d in yl if d['plugin_id'] == te.id), None)
                 if yd:
                     for ai in yd['actions']:
                         action, enabled = ai.split(',')
                         tt = next((ta for ta in te.additions if ta.model.id == action), None)
                         if tt:
                             tt.enabled = to_bool(enabled)

    def load_configuration(self):
        dm = self.dm
        sheet = dm.get_sheet(("Configuration", 4))
        for ri in dm.iterrows(sheet, 1):
            name = ri[0].value
            v = ri[1].value
            if name == "autogenerate_labnumber":
                v = to_bool(v)

            self.debug('setting "{}"={}'.format(name, v))
            if not hasattr(self, name):
                self.warning('Invalid configuration option "{}"'.format(name))
            else:
                setattr(self, name, v)

    def _get_switch_channel(self, data):
        if isinstance(data, dict):
            name = data['name']
        else:
            name = data
        name = str(name)
        ch = self._switch_mapping.get(name, '')
        inverted = False
        if ',' in str(ch):
            ch, inverted = ch.split(',')
            inverted = to_bool(inverted)

        #self.debug('get switch channel {} {}'.format(name, ch))
        return ch, inverted

    def _go_to_hole(self, data):
        if isinstance(data, dict):
            hole, autocenter = data['hole'], data['autocenter']
        else:
            hole, autocenter = data

        try:
            hole = int(hole)
            autocenter = to_bool(autocenter)
            err = self._manager.stage_manager.move_to_hole(str(hole),
                                                           correct_position=autocenter)
        except (ValueError, TypeError):
            err = InvalidArgumentsErrorCode('GoToHole', (hole, autocenter))

        return err or 'OK'

    def get_task_extensions(self, pid):
        import yaml

        p = paths.task_extensions_file
        with open(p, 'r') as rfile:
            yl = yaml.load(rfile)
            for yi in yl:
                # print yi['plugin_id'], pid
                if yi['plugin_id'].startswith(pid):
                    tid = yi.get('task_id', '')
                    for ai in yi['actions']:
                        a, e = ai.split(',')
                        # print tid, a, e
                        if to_bool(e):
                            yield tid, a

    def get_plugins(self, category=None, all_=False, element=False):
        tree = self.get_root()
        tree = tree.find('plugins')
        if category:
            cat = tree.find(category)
            if cat is not None:
                plugins = cat.findall('plugin')
        else:
            try:
                plugins = tree.iter(tag='plugin')
            except AttributeError:
                plugins = tree.getiterator(tag='plugin')

        if plugins:
            return [p if element else p.text.strip()
                    for p in plugins if all_ or to_bool(p.get('enabled'))]

    def activated(self):

        model = self._get_browser_model()
        self.browser_model = model
        if not model.is_activated:
            self._setup_browser_model()

        with no_update(self):
            self.browser_model.current_task_name = self.default_task_name

        # self._top_level_filter = None
        self.activate_workspace()

        self.browser_model.activated()

        if to_bool(self.application.preferences.get('pychron.dvc.enabled')):
            self.dvc = self.application.get_service('pychron.dvc.dvc.DVC')

    def _editor_factory(self, is_uv=False, **kw):
        klass = UVExperimentEditor if is_uv else ExperimentEditor
        editor = klass(application=self.application,
                       automated_runs_editable=self.automated_runs_editable,
                       **kw)

        prefs = self.application.preferences
        prefid = 'pychron.experiment'
        bgcolor = prefs.get('{}.bg_color'.format(prefid))
        even_bgcolor = prefs.get('{}.even_bg_color'.format(prefid))
        use_analysis_type_colors = to_bool(prefs.get('{}.use_analysis_type_colors'.format(prefid)))

        editor.setup_tabular_adapters(bgcolor, even_bgcolor,
                                      self._assemble_state_colors(),
                                      use_analysis_type_colors,
                                      self._assemble_analysis_type_colors())
        return editor

 def _get_parameters(self, subtree, tag, all_=False, element=False):
     if subtree is None:
         print subtree
     return [d if element else d.text.strip()
             for d in subtree.findall(tag)
             if all_ or to_bool(d.get('enabled'))]

    def _switch_factory(self, v_elem, klass=None):
        if klass is None:
            klass = HardwareValve

        name = v_elem.text.strip()
        address = v_elem.find('address')
        act_elem = v_elem.find('actuator')
        description = v_elem.find('description')

        positive_interlocks = [i.text.strip() for i in v_elem.findall('positive_interlock')]
        interlocks = [i.text.strip() for i in v_elem.findall('interlock')]
        if description is not None:
            description = description.text.strip()

        actname = act_elem.text.strip() if act_elem is not None else 'switch_controller'
        actuator = self.get_actuator_by_name(actname)
        if actuator is None:
            if not globalv.ignore_initialization_warnings:
                self.warning_dialog(
                    'No actuator for {}. Valve will not operate. Check setupfiles/extractionline/valves.xml'.format(
                        name))

        qs = True
        vqs = v_elem.get('query_state')
        if vqs:
            qs = vqs == 'true'

        parent = v_elem.find('parent')

        parent_name = ''
        parent_inverted = False
        if parent is not None:
            parent_name = parent.text.strip()
            inverted = parent.find('inverted')
            if inverted is not None:
                parent_inverted = to_bool(inverted.text.strip())

        check_actuation_enabled = True
        cae = v_elem.find('check_actuation_enabled')
        if cae is not None:
            check_actuation_enabled = to_bool(cae.text.strip())

        check_actuation_delay = 0
        cad = v_elem.find('check_actuation_delay')
        if cad is not None:
            check_actuation_delay = float(cad.text.strip())

        st = v_elem.find('settling_time')
        if st is not None:
            st = float(st.txt.strip())

        hv = klass(name,
                   address=address.text.strip() if address is not None else '',
                   parent=parent_name,
                   parent_inverted=parent_inverted,
                   check_actuation_enabled=check_actuation_enabled,
                   check_actuation_delay=check_actuation_delay,
                   actuator=actuator,
                   description=description,
                   query_state=qs,
                   positive_interlocks=positive_interlocks,
                   interlocks=interlocks,
                   settling_time=st or 0)
        return name, hv